From 5dff9d803f51daec471956861c1b45851a3f23db Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 29 Sep 2024 23:42:43 +0200 Subject: [PATCH 1/7] actually resolve from the lockfile --- cli/args/flags.rs | 36 ++++++++ cli/factory.rs | 2 +- cli/main.rs | 3 + cli/npm/managed/mod.rs | 6 +- cli/tools/registry/mod.rs | 1 + cli/tools/registry/pm.rs | 187 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 233 insertions(+), 2 deletions(-) diff --git a/cli/args/flags.rs b/cli/args/flags.rs index 13c93fa83132a0..197f5c1d47f917 100644 --- a/cli/args/flags.rs +++ b/cli/args/flags.rs @@ -307,6 +307,11 @@ impl LintFlags { } } +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct OutdatedFlags { + pub filters: Vec, +} + #[derive(Clone, Debug, Eq, PartialEq, Default)] pub struct ReplFlags { pub eval_files: Option>, @@ -456,6 +461,7 @@ pub enum DenoSubcommand { Uninstall(UninstallFlags), Lsp, Lint(LintFlags), + Outdated(OutdatedFlags), Repl(ReplFlags), Run(RunFlags), Serve(ServeFlags), @@ -1375,6 +1381,7 @@ pub fn flags_from_vec(args: Vec) -> clap::error::Result { "jupyter" => jupyter_parse(&mut flags, &mut m), "lint" => lint_parse(&mut flags, &mut m)?, "lsp" => lsp_parse(&mut flags, &mut m), + "outdated" => outdated_parse(&mut flags, &mut m)?, "repl" => repl_parse(&mut flags, &mut m)?, "run" => run_parse(&mut flags, &mut m, app, false)?, "serve" => serve_parse(&mut flags, &mut m, app)?, @@ -1594,6 +1601,7 @@ pub fn clap_root() -> Command { .subcommand(uninstall_subcommand()) .subcommand(lsp_subcommand()) .subcommand(lint_subcommand()) + .subcommand(outdated_subcommand()) .subcommand(publish_subcommand()) .subcommand(repl_subcommand()) .subcommand(task_subcommand()) @@ -2741,6 +2749,22 @@ To ignore linting on an entire file, you can add an ignore comment at the top of }) } +fn outdated_subcommand() -> Command { + command( + "outdated", + "Check for outdated dependencies", + UnstableArgsConfig::None, + ) + .defer(|cmd| { + cmd.arg( + Arg::new("filters") + .num_args(0..) + .action(ArgAction::Append) + .help("List of filters used for checking outdated packages"), + ) + }) +} + fn repl_subcommand() -> Command { command("repl", "Read Eval Print Loop", UnstableArgsConfig::ResolutionAndRuntime) .defer(|cmd| runtime_args(cmd, true, true) @@ -4756,6 +4780,18 @@ fn lsp_parse(flags: &mut Flags, _matches: &mut ArgMatches) { flags.subcommand = DenoSubcommand::Lsp; } +fn outdated_parse( + flags: &mut Flags, + matches: &mut ArgMatches, +) -> clap::error::Result<()> { + let filters = match matches.remove_many::("filters") { + Some(f) => f.collect(), + None => vec![], + }; + flags.subcommand = DenoSubcommand::Outdated(OutdatedFlags { filters }); + Ok(()) +} + fn lint_parse( flags: &mut Flags, matches: &mut ArgMatches, diff --git a/cli/factory.rs b/cli/factory.rs index 8aea635d2dd5b8..c4256dd86e17cf 100644 --- a/cli/factory.rs +++ b/cli/factory.rs @@ -359,7 +359,7 @@ impl CliFactory { let fs = self.fs(); let cli_options = self.cli_options()?; // For `deno install` we want to force the managed resolver so it can set up `node_modules/` directory. - create_cli_npm_resolver(if cli_options.use_byonm() && !matches!(cli_options.sub_command(), DenoSubcommand::Install(_) | DenoSubcommand::Add(_) | DenoSubcommand::Remove(_)) { + create_cli_npm_resolver(if cli_options.use_byonm() && !matches!(cli_options.sub_command(), DenoSubcommand::Install(_) | DenoSubcommand::Outdated(_) | DenoSubcommand::Add(_) | DenoSubcommand::Remove(_)) { CliNpmResolverCreateOptions::Byonm(CliNpmResolverByonmCreateOptions { fs: fs.clone(), root_node_modules_dir: Some(match cli_options.node_modules_dir_path() { diff --git a/cli/main.rs b/cli/main.rs index c0eccab5df9c77..b084231aff5a9e 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -271,6 +271,9 @@ async fn run_subcommand(flags: Arc) -> Result { "This deno was built without the \"upgrade\" feature. Please upgrade using the installation method originally used to install Deno.", 1, ), + DenoSubcommand::Outdated(outdated_flags) => spawn_subcommand(async { + tools::registry::outdated(flags, outdated_flags).await + }), DenoSubcommand::Vendor => exit_with_message("⚠️ `deno vendor` was removed in Deno 2.\n\nSee the Deno 1.x to 2.x Migration Guide for migration instructions: https://docs.deno.com/runtime/manual/advanced/migrate_deprecations", 1), DenoSubcommand::Publish(publish_flags) => spawn_subcommand(async { tools::registry::publish(flags, publish_flags).await diff --git a/cli/npm/managed/mod.rs b/cli/npm/managed/mod.rs index e3ac5e1af6eb91..c29699918ec19a 100644 --- a/cli/npm/managed/mod.rs +++ b/cli/npm/managed/mod.rs @@ -461,13 +461,17 @@ impl ManagedCliNpmResolver { self.resolve_pkg_folder_from_pkg_id(&pkg_id) } - fn resolve_pkg_id_from_pkg_req( + pub fn resolve_pkg_id_from_pkg_req( &self, req: &PackageReq, ) -> Result { self.resolution.resolve_pkg_id_from_pkg_req(req) } + pub fn npm_deps_provider(&self) -> Arc { + self.npm_install_deps_provider.clone() + } + /// Ensures that the top level `package.json` dependencies are installed. /// This may set up the `node_modules` directory. /// diff --git a/cli/tools/registry/mod.rs b/cli/tools/registry/mod.rs index 941514b0456e0e..14c6bb6a2e510f 100644 --- a/cli/tools/registry/mod.rs +++ b/cli/tools/registry/mod.rs @@ -66,6 +66,7 @@ use auth::get_auth_method; use auth::AuthMethod; pub use pm::add; pub use pm::cache_top_level_deps; +pub use pm::outdated; pub use pm::remove; pub use pm::AddCommandName; use publish_order::PublishOrderGraph; diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs index c92710f4602b80..74d4a6f497e4e1 100644 --- a/cli/tools/registry/pm.rs +++ b/cli/tools/registry/pm.rs @@ -2,6 +2,7 @@ mod cache_deps; +use crate::args::OutdatedFlags; pub use cache_deps::cache_top_level_deps; use deno_semver::jsr::JsrPackageReqReference; use deno_semver::npm::NpmPackageReqReference; @@ -568,6 +569,7 @@ pub async fn add( Ok(()) } +#[derive(Debug, PartialEq)] struct SelectedPackage { import_name: String, package_name: String, @@ -575,6 +577,7 @@ struct SelectedPackage { selected_version: String, } +#[derive(Debug, PartialEq)] enum PackageAndVersion { NotFound { package: String, @@ -876,6 +879,190 @@ fn update_config_file_content< .unwrap_or(new_text) } +#[derive(Debug)] +struct OutdatedPackage { + registry: String, + name: String, + current: String, + wanted: String, + latest: String, +} + +pub async fn outdated( + flags: Arc, + outdated_flags: OutdatedFlags, +) -> Result<(), AnyError> { + let factory = CliFactory::from_flags(flags); + let npm_resolver = factory.npm_resolver().await?; + let http_client = factory.http_client_provider(); + let deps_http_cache = factory.global_http_cache()?; + let mut deps_file_fetcher = FileFetcher::new( + deps_http_cache.clone(), + CacheSetting::ReloadAll, + true, + http_client.clone(), + Default::default(), + None, + ); + deps_file_fetcher.set_download_log_level(log::Level::Trace); + let deps_file_fetcher = Arc::new(deps_file_fetcher); + let jsr_resolver = Arc::new(JsrFetchResolver::new(deps_file_fetcher.clone())); + let npm_resolver2 = Arc::new(NpmFetchResolver::new(deps_file_fetcher)); + + // TODO: + // let top_level_deps = + // crate::tools::registry::get_top_level_deps(&factory, None).await?; + // eprintln!("top_level_deps {:#?}", top_level_deps); + + let mut outdated_packages = vec![]; + + if let Some(managed_npm_resolver) = npm_resolver.as_managed() { + let npm_deps_provider = managed_npm_resolver.npm_deps_provider(); + let pkgs = npm_deps_provider.remote_pkgs(); + + // eprintln!("pkgs {:#?}", pkgs); + + for pkg in pkgs { + let Ok(current_version) = + managed_npm_resolver.resolve_pkg_id_from_pkg_req(&pkg.req) + else { + continue; + }; + + let PackageAndVersion::Selected(package_and_version) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + AddPackageReq::parse(&format!("npm:{}", pkg.req)) + .unwrap() + .unwrap(), + ) + .await? + else { + continue; + }; + + // eprintln!("package and version {:#?}", package_and_version); + + let PackageAndVersion::Selected(package_and_version2) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + AddPackageReq::parse(&format!("npm:{}", pkg.req.name)) + .unwrap() + .unwrap(), + ) + .await? + else { + continue; + }; + + // eprintln!("package and version2 {:#?}", package_and_version2); + + if package_and_version == package_and_version2 { + continue; + } + + outdated_packages.push(OutdatedPackage { + registry: "npm".to_string(), + name: pkg.req.name.to_string(), + current: current_version.nv.version.to_string(), + wanted: package_and_version.selected_version, + latest: package_and_version2.selected_version, + }) + } + } + + if outdated_packages.is_empty() { + println!("No outdated packages found"); + } else { + display_table(&outdated_packages); + // TODO: print a table + // println!("----------------------------------------------"); + // println!( + // "| Package | Current | {} | {} |", + // crate::colors::green("Update"), + // crate::colors::cyan("Latest") + // ); + // println!("----------------------------------------------"); + + // for pkg in outdated_packages { + // println!( + // "| {}:{} | {} | {} | {} |", + // crate::colors::gray(pkg.registry), + // pkg.name, + // pkg.current, + // pkg.wanted, + // pkg.latest + // ); + // println!("----------------------------------------------"); + // } + } + Ok(()) +} + +fn display_table(packages: &[OutdatedPackage]) { + const HEADERS: [&str; 4] = ["Package", "Current", "Update", "Latest"]; + + let mut longest_cells: Vec<_> = HEADERS.iter().map(|h| h.len()).collect(); + + for package in packages { + longest_cells[0] = std::cmp::max( + HEADERS[0].len(), + package.registry.len() + package.name.len() + 1, + ); + longest_cells[1] = std::cmp::max(HEADERS[1].len(), package.current.len()); + longest_cells[2] = std::cmp::max(HEADERS[2].len(), package.wanted.len()); + longest_cells[3] = std::cmp::max(HEADERS[3].len(), package.latest.len()); + } + + let width = longest_cells + .clone() + .into_iter() + .reduce(|acc, e| acc + e + 5) + .unwrap_or(0) + + 2; + println!("{}", "-".repeat(width)); + println!( + "| {}{} | {}{} | {}{} | {}{} |", + " ".repeat(longest_cells[0] + 1 - HEADERS[0].len()), + HEADERS[0], + " ".repeat(longest_cells[1] + 1 - HEADERS[1].len()), + HEADERS[1], + " ".repeat(longest_cells[2] + 1 - HEADERS[2].len()), + HEADERS[2], + " ".repeat(longest_cells[3] + 1 - HEADERS[3].len()), + HEADERS[3], + ); + println!("{}", "-".repeat(width)); + for pkg in packages { + // println!( + // "{} {} {} {} {} {} {} {}", + // longest_cells[0] + 1 - pkg.name.len() - pkg.registry.len() - 1, + // pkg.name.len(), + // longest_cells[1] + 1 - pkg.current.len(), + // pkg.current.len(), + // longest_cells[2] + 1 - pkg.wanted.len(), + // pkg.wanted.len(), + // longest_cells[3] + 1 - pkg.latest.len(), + // pkg.latest.len(), + // ); + println!( + "| {}{}:{} | {}{} | {}{} | {}{} |", + crate::colors::gray(&pkg.registry), + " " + .repeat(longest_cells[0] + 1 - pkg.name.len() - pkg.registry.len() - 1), + pkg.name, + " ".repeat(longest_cells[1] + 1 - pkg.current.len()), + pkg.current, + " ".repeat(longest_cells[2] + 1 - pkg.wanted.len()), + pkg.wanted, + " ".repeat(longest_cells[3] + 1 - pkg.latest.len()), + pkg.latest, + ); + println!("{}", "-".repeat(width)); + } +} #[cfg(test)] mod test { use super::*; From 066a8a9e796454f1006639c1d756561bcad7de91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 29 Sep 2024 23:53:19 +0200 Subject: [PATCH 2/7] bit better table --- cli/tools/registry/pm.rs | 87 ++++++++++++++++------------------------ 1 file changed, 34 insertions(+), 53 deletions(-) diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs index 74d4a6f497e4e1..8d2cc65e95fc8d 100644 --- a/cli/tools/registry/pm.rs +++ b/cli/tools/registry/pm.rs @@ -4,6 +4,7 @@ mod cache_deps; use crate::args::OutdatedFlags; pub use cache_deps::cache_top_level_deps; +use deno_runtime::colors; use deno_semver::jsr::JsrPackageReqReference; use deno_semver::npm::NpmPackageReqReference; use deno_semver::VersionReq; @@ -929,7 +930,7 @@ pub async fn outdated( continue; }; - let PackageAndVersion::Selected(package_and_version) = + let PackageAndVersion::Selected(wanted_package_and_version) = find_package_and_select_version_for_req( jsr_resolver.clone(), npm_resolver2.clone(), @@ -942,9 +943,7 @@ pub async fn outdated( continue; }; - // eprintln!("package and version {:#?}", package_and_version); - - let PackageAndVersion::Selected(package_and_version2) = + let PackageAndVersion::Selected(latest_package_and_version) = find_package_and_select_version_for_req( jsr_resolver.clone(), npm_resolver2.clone(), @@ -957,9 +956,7 @@ pub async fn outdated( continue; }; - // eprintln!("package and version2 {:#?}", package_and_version2); - - if package_and_version == package_and_version2 { + if wanted_package_and_version == latest_package_and_version { continue; } @@ -967,8 +964,8 @@ pub async fn outdated( registry: "npm".to_string(), name: pkg.req.name.to_string(), current: current_version.nv.version.to_string(), - wanted: package_and_version.selected_version, - latest: package_and_version2.selected_version, + wanted: wanted_package_and_version.selected_version, + latest: latest_package_and_version.selected_version, }) } } @@ -977,26 +974,6 @@ pub async fn outdated( println!("No outdated packages found"); } else { display_table(&outdated_packages); - // TODO: print a table - // println!("----------------------------------------------"); - // println!( - // "| Package | Current | {} | {} |", - // crate::colors::green("Update"), - // crate::colors::cyan("Latest") - // ); - // println!("----------------------------------------------"); - - // for pkg in outdated_packages { - // println!( - // "| {}:{} | {} | {} | {} |", - // crate::colors::gray(pkg.registry), - // pkg.name, - // pkg.current, - // pkg.wanted, - // pkg.latest - // ); - // println!("----------------------------------------------"); - // } } Ok(()) } @@ -1020,38 +997,32 @@ fn display_table(packages: &[OutdatedPackage]) { .clone() .into_iter() .reduce(|acc, e| acc + e + 5) - .unwrap_or(0) - + 2; - println!("{}", "-".repeat(width)); + .unwrap_or(0); + println!("┌{}┐", "─".repeat(width)); println!( - "| {}{} | {}{} | {}{} | {}{} |", + "│ {}{} │ {}{} │ {}{} │ {}{} │", " ".repeat(longest_cells[0] + 1 - HEADERS[0].len()), - HEADERS[0], + colors::intense_blue(HEADERS[0]), " ".repeat(longest_cells[1] + 1 - HEADERS[1].len()), - HEADERS[1], + colors::intense_blue(HEADERS[1]), " ".repeat(longest_cells[2] + 1 - HEADERS[2].len()), - HEADERS[2], + colors::intense_blue(HEADERS[2]), " ".repeat(longest_cells[3] + 1 - HEADERS[3].len()), - HEADERS[3], + colors::intense_blue(HEADERS[3]), ); - println!("{}", "-".repeat(width)); - for pkg in packages { - // println!( - // "{} {} {} {} {} {} {} {}", - // longest_cells[0] + 1 - pkg.name.len() - pkg.registry.len() - 1, - // pkg.name.len(), - // longest_cells[1] + 1 - pkg.current.len(), - // pkg.current.len(), - // longest_cells[2] + 1 - pkg.wanted.len(), - // pkg.wanted.len(), - // longest_cells[3] + 1 - pkg.latest.len(), - // pkg.latest.len(), - // ); + println!( + "├{}┼{}┼{}┼{}┤", + "─".repeat(longest_cells[0] + 3), + "─".repeat(longest_cells[1] + 3), + "─".repeat(longest_cells[2] + 3), + "─".repeat(longest_cells[3] + 3), + ); + for (idx, pkg) in packages.iter().enumerate() { println!( - "| {}{}:{} | {}{} | {}{} | {}{} |", - crate::colors::gray(&pkg.registry), + "│ {}{}:{} │ {}{} │ {}{} │ {}{} │", " " .repeat(longest_cells[0] + 1 - pkg.name.len() - pkg.registry.len() - 1), + crate::colors::gray(&pkg.registry), pkg.name, " ".repeat(longest_cells[1] + 1 - pkg.current.len()), pkg.current, @@ -1060,7 +1031,17 @@ fn display_table(packages: &[OutdatedPackage]) { " ".repeat(longest_cells[3] + 1 - pkg.latest.len()), pkg.latest, ); - println!("{}", "-".repeat(width)); + if idx < packages.len() - 1 { + println!( + "├{}┼{}┼{}┼{}┤", + "─".repeat(longest_cells[0] + 3), + "─".repeat(longest_cells[1] + 3), + "─".repeat(longest_cells[2] + 3), + "─".repeat(longest_cells[3] + 3), + ); + } else { + println!("└{}┘", "─".repeat(width)); + } } } #[cfg(test)] From a3f91f1d5fe7246a252e7d6c7639b5ec8dffba55 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 30 Sep 2024 23:43:32 +0200 Subject: [PATCH 3/7] wip --- cli/tools/registry/pm.rs | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs index 8d2cc65e95fc8d..d4d81f7d058a03 100644 --- a/cli/tools/registry/pm.rs +++ b/cli/tools/registry/pm.rs @@ -891,9 +891,18 @@ struct OutdatedPackage { pub async fn outdated( flags: Arc, + // TODO(bartlomieju): support filters outdated_flags: OutdatedFlags, ) -> Result<(), AnyError> { let factory = CliFactory::from_flags(flags); + let options = factory.cli_options()?; + + // TODO(bartlomieju): check if lockfile is out of date? + if options.maybe_lockfile().is_none() { + bail!( + "No lockfile provided. Install dependencies first using `deno install`." + ); + } let npm_resolver = factory.npm_resolver().await?; let http_client = factory.http_client_provider(); let deps_http_cache = factory.global_http_cache()?; @@ -1011,7 +1020,7 @@ fn display_table(packages: &[OutdatedPackage]) { colors::intense_blue(HEADERS[3]), ); println!( - "├{}┼{}┼{}┼{}┤", + "│{}┼{}┼{}┼{}│", "─".repeat(longest_cells[0] + 3), "─".repeat(longest_cells[1] + 3), "─".repeat(longest_cells[2] + 3), @@ -1033,7 +1042,7 @@ fn display_table(packages: &[OutdatedPackage]) { ); if idx < packages.len() - 1 { println!( - "├{}┼{}┼{}┼{}┤", + "│{}┼{}┼{}┼{}│", "─".repeat(longest_cells[0] + 3), "─".repeat(longest_cells[1] + 3), "─".repeat(longest_cells[2] + 3), From d4ffeb98a24f7f10782c2c4d057bf4d8b3bb647a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 1 Oct 2024 00:27:14 +0200 Subject: [PATCH 4/7] basic jsr support --- cli/tools/registry/pm.rs | 95 ++++++++++++++++++++++++++--- cli/tools/registry/pm/cache_deps.rs | 89 +++++++++++++++++++++++++++ 2 files changed, 176 insertions(+), 8 deletions(-) diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs index d4d81f7d058a03..27594e335f9335 100644 --- a/cli/tools/registry/pm.rs +++ b/cli/tools/registry/pm.rs @@ -7,6 +7,8 @@ pub use cache_deps::cache_top_level_deps; use deno_runtime::colors; use deno_semver::jsr::JsrPackageReqReference; use deno_semver::npm::NpmPackageReqReference; +use deno_semver::VersionRange; +use deno_semver::VersionRangeSet; use deno_semver::VersionReq; use std::borrow::Cow; @@ -919,13 +921,90 @@ pub async fn outdated( let jsr_resolver = Arc::new(JsrFetchResolver::new(deps_file_fetcher.clone())); let npm_resolver2 = Arc::new(NpmFetchResolver::new(deps_file_fetcher)); - // TODO: - // let top_level_deps = - // crate::tools::registry::get_top_level_deps(&factory, None).await?; - // eprintln!("top_level_deps {:#?}", top_level_deps); + let top_level_deps = + self::cache_deps::find_top_level_deps(&factory, Some(jsr_resolver.clone())) + .await?; + eprintln!("top_level_deps {:#?}", top_level_deps); let mut outdated_packages = vec![]; + for top_level_dep in top_level_deps { + let url_str = top_level_dep.as_str(); + + let add_package_req = AddPackageReq::parse(top_level_dep.as_str()) + .unwrap() + .unwrap(); + let mut add_package_req2 = AddPackageReq::parse(top_level_dep.as_str()) + .unwrap() + .unwrap(); + let add_package_req3 = AddPackageReq::parse(top_level_dep.as_str()) + .unwrap() + .unwrap(); + match &mut add_package_req2.value { + AddPackageReqValue::Jsr(ref mut req) => { + req.version_req = VersionReq::from_raw_text_and_inner( + "*".to_string(), + deno_semver::RangeSetOrTag::RangeSet(VersionRangeSet(vec![ + VersionRange::all(), + ])), + ); + } + AddPackageReqValue::Npm(ref mut req) => { + req.version_req = VersionReq::from_raw_text_and_inner( + "*".to_string(), + deno_semver::RangeSetOrTag::RangeSet(VersionRangeSet(vec![ + VersionRange::all(), + ])), + ); + } + }; + + let PackageAndVersion::Selected(wanted_package_and_version) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + add_package_req, + ) + .await? + else { + continue; + }; + + let PackageAndVersion::Selected(latest_package_and_version) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + add_package_req2, + ) + .await? + else { + continue; + }; + + eprintln!( + "wanted_package_and_version {:#?}", + wanted_package_and_version + ); + eprintln!( + "latest_package_and_version {:#?}", + latest_package_and_version + ); + // if wanted_package_and_version == latest_package_and_version { + // continue; + // } + + outdated_packages.push(OutdatedPackage { + registry: top_level_dep.scheme().to_string(), + name: add_package_req3.alias.to_string(), + current: match add_package_req3.value { + AddPackageReqValue::Jsr(req) => req.version_req.to_string(), + AddPackageReqValue::Npm(req) => req.version_req.to_string(), + }, + wanted: wanted_package_and_version.selected_version, + latest: latest_package_and_version.selected_version, + }) + } + if let Some(managed_npm_resolver) = npm_resolver.as_managed() { let npm_deps_provider = managed_npm_resolver.npm_deps_provider(); let pkgs = npm_deps_provider.remote_pkgs(); @@ -994,12 +1073,12 @@ fn display_table(packages: &[OutdatedPackage]) { for package in packages { longest_cells[0] = std::cmp::max( - HEADERS[0].len(), + longest_cells[0], package.registry.len() + package.name.len() + 1, ); - longest_cells[1] = std::cmp::max(HEADERS[1].len(), package.current.len()); - longest_cells[2] = std::cmp::max(HEADERS[2].len(), package.wanted.len()); - longest_cells[3] = std::cmp::max(HEADERS[3].len(), package.latest.len()); + longest_cells[1] = std::cmp::max(longest_cells[1], package.current.len()); + longest_cells[2] = std::cmp::max(longest_cells[2], package.wanted.len()); + longest_cells[3] = std::cmp::max(longest_cells[3], package.latest.len()); } let width = longest_cells diff --git a/cli/tools/registry/pm/cache_deps.rs b/cli/tools/registry/pm/cache_deps.rs index 7d1773b34305ea..b5ac96a674b813 100644 --- a/cli/tools/registry/pm/cache_deps.rs +++ b/cli/tools/registry/pm/cache_deps.rs @@ -8,8 +8,97 @@ use crate::graph_container::ModuleGraphUpdatePermit; use deno_core::error::AnyError; use deno_core::futures::stream::FuturesUnordered; use deno_core::futures::StreamExt; +use deno_core::url::Url; use deno_semver::package::PackageReq; +pub async fn find_top_level_deps( + factory: &CliFactory, + jsr_resolver: Option>, +) -> Result, AnyError> { + let npm_resolver = factory.npm_resolver().await?; + let cli_options = factory.cli_options()?; + let root_permissions = factory.root_permissions_container()?; + // if let Some(npm_resolver) = npm_resolver.as_managed() { + // if !npm_resolver.ensure_top_level_package_json_install().await? { + // if let Some(lockfile) = cli_options.maybe_lockfile() { + // lockfile.error_if_changed()?; + // } + + // npm_resolver.cache_packages().await?; + // } + // } + + let mut roots = Vec::new(); + + let resolver = factory.workspace_resolver().await?; + if let Some(import_map) = resolver.maybe_import_map() { + let jsr_resolver = if let Some(resolver) = jsr_resolver { + resolver + } else { + Arc::new(crate::jsr::JsrFetchResolver::new( + factory.file_fetcher()?.clone(), + )) + }; + + let mut info_futures = FuturesUnordered::new(); + + let mut seen_reqs = std::collections::HashSet::new(); + + for entry in import_map.imports().entries() { + let Some(specifier) = entry.value else { + continue; + }; + + match specifier.scheme() { + "jsr" => { + let specifier_str = specifier.as_str(); + let specifier_str = + specifier_str.strip_prefix("jsr:").unwrap_or(specifier_str); + if let Ok(req) = PackageReq::from_str(specifier_str) { + if !seen_reqs.insert(req.clone()) { + continue; + } + let jsr_resolver = jsr_resolver.clone(); + info_futures.push(async move { + if let Some(nv) = jsr_resolver.req_to_nv(&req).await { + if let Some(info) = jsr_resolver.package_version_info(&nv).await + { + return Some((specifier.clone(), info)); + } + } + None + }); + } + } + "npm" => roots.push(specifier.clone()), + _ => { + if entry.key.ends_with('/') && specifier.as_str().ends_with('/') { + continue; + } + roots.push(specifier.clone()); + } + } + } + + while let Some(info_future) = info_futures.next().await { + if let Some((specifier, info)) = info_future { + if info.export(".").is_some() { + roots.push(specifier.clone()); + continue; + } + let exports = info.exports(); + for (k, _) in exports { + if let Ok(spec) = specifier.join(k) { + roots.push(spec); + } + } + } + } + } + + Ok(roots) +} + pub async fn cache_top_level_deps( factory: &CliFactory, jsr_resolver: Option>, From 826b8644e7359ca2ca643e151fd019fb2c0d4f7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 1 Oct 2024 01:01:18 +0200 Subject: [PATCH 5/7] basic jsr support2 --- cli/tools/registry/pm.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs index 27594e335f9335..f195b194dd9f53 100644 --- a/cli/tools/registry/pm.rs +++ b/cli/tools/registry/pm.rs @@ -1058,6 +1058,8 @@ pub async fn outdated( } } + if !outdated_flags.filters.is_empty() {} + if outdated_packages.is_empty() { println!("No outdated packages found"); } else { From 5f6a6ef0a8297c14587074d5608a1318424fd04c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 1 Oct 2024 01:19:59 +0200 Subject: [PATCH 6/7] reorg, basic filtering --- cli/tools/registry/pm.rs | 263 +----------------------- cli/tools/registry/pm/outdated.rs | 324 ++++++++++++++++++++++++++++++ 2 files changed, 329 insertions(+), 258 deletions(-) create mode 100644 cli/tools/registry/pm/outdated.rs diff --git a/cli/tools/registry/pm.rs b/cli/tools/registry/pm.rs index f195b194dd9f53..89dfba47e52a1a 100644 --- a/cli/tools/registry/pm.rs +++ b/cli/tools/registry/pm.rs @@ -1,14 +1,8 @@ // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. -mod cache_deps; - -use crate::args::OutdatedFlags; pub use cache_deps::cache_top_level_deps; -use deno_runtime::colors; use deno_semver::jsr::JsrPackageReqReference; use deno_semver::npm::NpmPackageReqReference; -use deno_semver::VersionRange; -use deno_semver::VersionRangeSet; use deno_semver::VersionReq; use std::borrow::Cow; @@ -42,6 +36,11 @@ use crate::file_fetcher::FileFetcher; use crate::jsr::JsrFetchResolver; use crate::npm::NpmFetchResolver; +mod cache_deps; +mod outdated; + +pub use outdated::outdated; + enum DenoConfigFormat { Json, Jsonc, @@ -882,258 +881,6 @@ fn update_config_file_content< .unwrap_or(new_text) } -#[derive(Debug)] -struct OutdatedPackage { - registry: String, - name: String, - current: String, - wanted: String, - latest: String, -} - -pub async fn outdated( - flags: Arc, - // TODO(bartlomieju): support filters - outdated_flags: OutdatedFlags, -) -> Result<(), AnyError> { - let factory = CliFactory::from_flags(flags); - let options = factory.cli_options()?; - - // TODO(bartlomieju): check if lockfile is out of date? - if options.maybe_lockfile().is_none() { - bail!( - "No lockfile provided. Install dependencies first using `deno install`." - ); - } - let npm_resolver = factory.npm_resolver().await?; - let http_client = factory.http_client_provider(); - let deps_http_cache = factory.global_http_cache()?; - let mut deps_file_fetcher = FileFetcher::new( - deps_http_cache.clone(), - CacheSetting::ReloadAll, - true, - http_client.clone(), - Default::default(), - None, - ); - deps_file_fetcher.set_download_log_level(log::Level::Trace); - let deps_file_fetcher = Arc::new(deps_file_fetcher); - let jsr_resolver = Arc::new(JsrFetchResolver::new(deps_file_fetcher.clone())); - let npm_resolver2 = Arc::new(NpmFetchResolver::new(deps_file_fetcher)); - - let top_level_deps = - self::cache_deps::find_top_level_deps(&factory, Some(jsr_resolver.clone())) - .await?; - eprintln!("top_level_deps {:#?}", top_level_deps); - - let mut outdated_packages = vec![]; - - for top_level_dep in top_level_deps { - let url_str = top_level_dep.as_str(); - - let add_package_req = AddPackageReq::parse(top_level_dep.as_str()) - .unwrap() - .unwrap(); - let mut add_package_req2 = AddPackageReq::parse(top_level_dep.as_str()) - .unwrap() - .unwrap(); - let add_package_req3 = AddPackageReq::parse(top_level_dep.as_str()) - .unwrap() - .unwrap(); - match &mut add_package_req2.value { - AddPackageReqValue::Jsr(ref mut req) => { - req.version_req = VersionReq::from_raw_text_and_inner( - "*".to_string(), - deno_semver::RangeSetOrTag::RangeSet(VersionRangeSet(vec![ - VersionRange::all(), - ])), - ); - } - AddPackageReqValue::Npm(ref mut req) => { - req.version_req = VersionReq::from_raw_text_and_inner( - "*".to_string(), - deno_semver::RangeSetOrTag::RangeSet(VersionRangeSet(vec![ - VersionRange::all(), - ])), - ); - } - }; - - let PackageAndVersion::Selected(wanted_package_and_version) = - find_package_and_select_version_for_req( - jsr_resolver.clone(), - npm_resolver2.clone(), - add_package_req, - ) - .await? - else { - continue; - }; - - let PackageAndVersion::Selected(latest_package_and_version) = - find_package_and_select_version_for_req( - jsr_resolver.clone(), - npm_resolver2.clone(), - add_package_req2, - ) - .await? - else { - continue; - }; - - eprintln!( - "wanted_package_and_version {:#?}", - wanted_package_and_version - ); - eprintln!( - "latest_package_and_version {:#?}", - latest_package_and_version - ); - // if wanted_package_and_version == latest_package_and_version { - // continue; - // } - - outdated_packages.push(OutdatedPackage { - registry: top_level_dep.scheme().to_string(), - name: add_package_req3.alias.to_string(), - current: match add_package_req3.value { - AddPackageReqValue::Jsr(req) => req.version_req.to_string(), - AddPackageReqValue::Npm(req) => req.version_req.to_string(), - }, - wanted: wanted_package_and_version.selected_version, - latest: latest_package_and_version.selected_version, - }) - } - - if let Some(managed_npm_resolver) = npm_resolver.as_managed() { - let npm_deps_provider = managed_npm_resolver.npm_deps_provider(); - let pkgs = npm_deps_provider.remote_pkgs(); - - // eprintln!("pkgs {:#?}", pkgs); - - for pkg in pkgs { - let Ok(current_version) = - managed_npm_resolver.resolve_pkg_id_from_pkg_req(&pkg.req) - else { - continue; - }; - - let PackageAndVersion::Selected(wanted_package_and_version) = - find_package_and_select_version_for_req( - jsr_resolver.clone(), - npm_resolver2.clone(), - AddPackageReq::parse(&format!("npm:{}", pkg.req)) - .unwrap() - .unwrap(), - ) - .await? - else { - continue; - }; - - let PackageAndVersion::Selected(latest_package_and_version) = - find_package_and_select_version_for_req( - jsr_resolver.clone(), - npm_resolver2.clone(), - AddPackageReq::parse(&format!("npm:{}", pkg.req.name)) - .unwrap() - .unwrap(), - ) - .await? - else { - continue; - }; - - if wanted_package_and_version == latest_package_and_version { - continue; - } - - outdated_packages.push(OutdatedPackage { - registry: "npm".to_string(), - name: pkg.req.name.to_string(), - current: current_version.nv.version.to_string(), - wanted: wanted_package_and_version.selected_version, - latest: latest_package_and_version.selected_version, - }) - } - } - - if !outdated_flags.filters.is_empty() {} - - if outdated_packages.is_empty() { - println!("No outdated packages found"); - } else { - display_table(&outdated_packages); - } - Ok(()) -} - -fn display_table(packages: &[OutdatedPackage]) { - const HEADERS: [&str; 4] = ["Package", "Current", "Update", "Latest"]; - - let mut longest_cells: Vec<_> = HEADERS.iter().map(|h| h.len()).collect(); - - for package in packages { - longest_cells[0] = std::cmp::max( - longest_cells[0], - package.registry.len() + package.name.len() + 1, - ); - longest_cells[1] = std::cmp::max(longest_cells[1], package.current.len()); - longest_cells[2] = std::cmp::max(longest_cells[2], package.wanted.len()); - longest_cells[3] = std::cmp::max(longest_cells[3], package.latest.len()); - } - - let width = longest_cells - .clone() - .into_iter() - .reduce(|acc, e| acc + e + 5) - .unwrap_or(0); - println!("┌{}┐", "─".repeat(width)); - println!( - "│ {}{} │ {}{} │ {}{} │ {}{} │", - " ".repeat(longest_cells[0] + 1 - HEADERS[0].len()), - colors::intense_blue(HEADERS[0]), - " ".repeat(longest_cells[1] + 1 - HEADERS[1].len()), - colors::intense_blue(HEADERS[1]), - " ".repeat(longest_cells[2] + 1 - HEADERS[2].len()), - colors::intense_blue(HEADERS[2]), - " ".repeat(longest_cells[3] + 1 - HEADERS[3].len()), - colors::intense_blue(HEADERS[3]), - ); - println!( - "│{}┼{}┼{}┼{}│", - "─".repeat(longest_cells[0] + 3), - "─".repeat(longest_cells[1] + 3), - "─".repeat(longest_cells[2] + 3), - "─".repeat(longest_cells[3] + 3), - ); - for (idx, pkg) in packages.iter().enumerate() { - println!( - "│ {}{}:{} │ {}{} │ {}{} │ {}{} │", - " " - .repeat(longest_cells[0] + 1 - pkg.name.len() - pkg.registry.len() - 1), - crate::colors::gray(&pkg.registry), - pkg.name, - " ".repeat(longest_cells[1] + 1 - pkg.current.len()), - pkg.current, - " ".repeat(longest_cells[2] + 1 - pkg.wanted.len()), - pkg.wanted, - " ".repeat(longest_cells[3] + 1 - pkg.latest.len()), - pkg.latest, - ); - if idx < packages.len() - 1 { - println!( - "│{}┼{}┼{}┼{}│", - "─".repeat(longest_cells[0] + 3), - "─".repeat(longest_cells[1] + 3), - "─".repeat(longest_cells[2] + 3), - "─".repeat(longest_cells[3] + 3), - ); - } else { - println!("└{}┘", "─".repeat(width)); - } - } -} #[cfg(test)] mod test { use super::*; diff --git a/cli/tools/registry/pm/outdated.rs b/cli/tools/registry/pm/outdated.rs new file mode 100644 index 00000000000000..9ad9727a87a3fb --- /dev/null +++ b/cli/tools/registry/pm/outdated.rs @@ -0,0 +1,324 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +use deno_core::anyhow::bail; +use deno_core::error::AnyError; +use deno_runtime::colors; +use deno_semver::VersionRange; +use deno_semver::VersionRangeSet; +use deno_semver::VersionReq; +use std::sync::Arc; + +use crate::args::CacheSetting; +use crate::args::Flags; +use crate::args::OutdatedFlags; +use crate::factory::CliFactory; +use crate::file_fetcher::FileFetcher; +use crate::jsr::JsrFetchResolver; +use crate::npm::NpmFetchResolver; + +use super::cache_deps::find_top_level_deps; +use super::find_package_and_select_version_for_req; +use super::AddPackageReq; +use super::AddPackageReqValue; +use super::PackageAndVersion; + +#[derive(Debug)] +struct OutdatedPackage { + registry: String, + name: String, + current: String, + wanted: String, + latest: String, +} + +pub async fn outdated( + flags: Arc, + outdated_flags: OutdatedFlags, +) -> Result<(), AnyError> { + let factory = CliFactory::from_flags(flags); + let options = factory.cli_options()?; + + // TODO(bartlomieju): check if lockfile is out of date? + if options.maybe_lockfile().is_none() { + bail!( + "No lockfile provided. Install dependencies first using `deno install`." + ); + } + let npm_resolver = factory.npm_resolver().await?; + let http_client = factory.http_client_provider(); + let deps_http_cache = factory.global_http_cache()?; + let mut deps_file_fetcher = FileFetcher::new( + deps_http_cache.clone(), + CacheSetting::ReloadAll, + true, + http_client.clone(), + Default::default(), + None, + ); + deps_file_fetcher.set_download_log_level(log::Level::Trace); + let deps_file_fetcher = Arc::new(deps_file_fetcher); + let jsr_resolver = Arc::new(JsrFetchResolver::new(deps_file_fetcher.clone())); + let npm_resolver2 = Arc::new(NpmFetchResolver::new(deps_file_fetcher)); + + let top_level_deps = + find_top_level_deps(&factory, Some(jsr_resolver.clone())).await?; + eprintln!("top_level_deps {:#?}", top_level_deps); + + let mut outdated_packages = vec![]; + + for top_level_dep in top_level_deps { + let url_str = top_level_dep.as_str(); + + let add_package_req = AddPackageReq::parse(top_level_dep.as_str()) + .unwrap() + .unwrap(); + let mut add_package_req2 = AddPackageReq::parse(top_level_dep.as_str()) + .unwrap() + .unwrap(); + let add_package_req3 = AddPackageReq::parse(top_level_dep.as_str()) + .unwrap() + .unwrap(); + match &mut add_package_req2.value { + AddPackageReqValue::Jsr(ref mut req) => { + req.version_req = VersionReq::from_raw_text_and_inner( + "*".to_string(), + deno_semver::RangeSetOrTag::RangeSet(VersionRangeSet(vec![ + VersionRange::all(), + ])), + ); + } + AddPackageReqValue::Npm(ref mut req) => { + req.version_req = VersionReq::from_raw_text_and_inner( + "*".to_string(), + deno_semver::RangeSetOrTag::RangeSet(VersionRangeSet(vec![ + VersionRange::all(), + ])), + ); + } + }; + + let PackageAndVersion::Selected(wanted_package_and_version) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + add_package_req, + ) + .await? + else { + continue; + }; + + let PackageAndVersion::Selected(latest_package_and_version) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + add_package_req2, + ) + .await? + else { + continue; + }; + + eprintln!( + "wanted_package_and_version {:#?}", + wanted_package_and_version + ); + eprintln!( + "latest_package_and_version {:#?}", + latest_package_and_version + ); + // if wanted_package_and_version == latest_package_and_version { + // continue; + // } + + outdated_packages.push(OutdatedPackage { + registry: top_level_dep.scheme().to_string(), + name: add_package_req3.alias.to_string(), + current: match add_package_req3.value { + AddPackageReqValue::Jsr(req) => req.version_req.to_string(), + AddPackageReqValue::Npm(req) => req.version_req.to_string(), + }, + wanted: wanted_package_and_version.selected_version, + latest: latest_package_and_version.selected_version, + }) + } + + if let Some(managed_npm_resolver) = npm_resolver.as_managed() { + let npm_deps_provider = managed_npm_resolver.npm_deps_provider(); + let pkgs = npm_deps_provider.remote_pkgs(); + + // eprintln!("pkgs {:#?}", pkgs); + + for pkg in pkgs { + let Ok(current_version) = + managed_npm_resolver.resolve_pkg_id_from_pkg_req(&pkg.req) + else { + continue; + }; + + let PackageAndVersion::Selected(wanted_package_and_version) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + AddPackageReq::parse(&format!("npm:{}", pkg.req)) + .unwrap() + .unwrap(), + ) + .await? + else { + continue; + }; + + let PackageAndVersion::Selected(latest_package_and_version) = + find_package_and_select_version_for_req( + jsr_resolver.clone(), + npm_resolver2.clone(), + AddPackageReq::parse(&format!("npm:{}", pkg.req.name)) + .unwrap() + .unwrap(), + ) + .await? + else { + continue; + }; + + // TODO(bartlomieju): this condition seems fishy, is it actually needed? + if wanted_package_and_version == latest_package_and_version { + continue; + } + + outdated_packages.push(OutdatedPackage { + registry: "npm".to_string(), + name: pkg.req.name.to_string(), + current: current_version.nv.version.to_string(), + wanted: wanted_package_and_version.selected_version, + latest: latest_package_and_version.selected_version, + }) + } + } + + if !outdated_flags.filters.is_empty() { + let filters = OutdatedFilters::from_options(outdated_flags.filters)?; + outdated_packages = outdated_packages + .into_iter() + .filter(|pkg| { + for exclude in &filters.exclude { + if pkg.name.starts_with(exclude) { + return false; + } + } + + if !filters.include.is_empty() { + for include in &filters.include { + if pkg.name.starts_with(include) { + return true; + } + } + + return false; + } + + true + }) + .collect(); + } + + if outdated_packages.is_empty() { + println!("No outdated packages found"); + } else { + display_table(&outdated_packages); + } + Ok(()) +} + +fn display_table(packages: &[OutdatedPackage]) { + const HEADERS: [&str; 4] = ["Package", "Current", "Update", "Latest"]; + + let mut longest_cells: Vec<_> = HEADERS.iter().map(|h| h.len()).collect(); + + for package in packages { + longest_cells[0] = std::cmp::max( + longest_cells[0], + package.registry.len() + package.name.len() + 1, + ); + longest_cells[1] = std::cmp::max(longest_cells[1], package.current.len()); + longest_cells[2] = std::cmp::max(longest_cells[2], package.wanted.len()); + longest_cells[3] = std::cmp::max(longest_cells[3], package.latest.len()); + } + + let width = longest_cells + .clone() + .into_iter() + .reduce(|acc, e| acc + e + 5) + .unwrap_or(0); + println!("┌{}┐", "─".repeat(width)); + println!( + "│ {}{} │ {}{} │ {}{} │ {}{} │", + colors::intense_blue(HEADERS[0]), + " ".repeat(longest_cells[0] + 1 - HEADERS[0].len()), + " ".repeat(longest_cells[1] + 1 - HEADERS[1].len()), + colors::intense_blue(HEADERS[1]), + " ".repeat(longest_cells[2] + 1 - HEADERS[2].len()), + colors::intense_blue(HEADERS[2]), + " ".repeat(longest_cells[3] + 1 - HEADERS[3].len()), + colors::intense_blue(HEADERS[3]), + ); + println!( + "│{}┼{}┼{}┼{}│", + "─".repeat(longest_cells[0] + 3), + "─".repeat(longest_cells[1] + 3), + "─".repeat(longest_cells[2] + 3), + "─".repeat(longest_cells[3] + 3), + ); + for (idx, pkg) in packages.iter().enumerate() { + println!( + "│ {}{}{}{} │ {}{} │ {}{} │ {}{} │", + crate::colors::gray(&pkg.registry), + crate::colors::gray(":"), + pkg.name, + " " + .repeat(longest_cells[0] + 1 - pkg.name.len() - pkg.registry.len() - 1), + " ".repeat(longest_cells[1] + 1 - pkg.current.len()), + pkg.current, + " ".repeat(longest_cells[2] + 1 - pkg.wanted.len()), + pkg.wanted, + " ".repeat(longest_cells[3] + 1 - pkg.latest.len()), + pkg.latest, + ); + if idx < packages.len() - 1 { + println!( + "│{}┼{}┼{}┼{}│", + "─".repeat(longest_cells[0] + 3), + "─".repeat(longest_cells[1] + 3), + "─".repeat(longest_cells[2] + 3), + "─".repeat(longest_cells[3] + 3), + ); + } else { + println!("└{}┘", "─".repeat(width)); + } + } +} + +struct OutdatedFilters { + include: Vec, + exclude: Vec, +} + +impl OutdatedFilters { + fn from_options(filters: Vec) -> Result { + let mut f = Self { + include: vec![], + exclude: vec![], + }; + + for filter in filters { + if let Some(filter) = filter.strip_prefix('!') { + f.exclude.push(filter.to_string()); + } else { + f.include.push(filter); + } + } + + Ok(f) + } +} From b22d03b55659a4adee9752a0250d703a5080f263 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 1 Oct 2024 21:41:19 +0200 Subject: [PATCH 7/7] remove logs --- cli/tools/registry/pm/outdated.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/cli/tools/registry/pm/outdated.rs b/cli/tools/registry/pm/outdated.rs index 9ad9727a87a3fb..47ca51a0892eb7 100644 --- a/cli/tools/registry/pm/outdated.rs +++ b/cli/tools/registry/pm/outdated.rs @@ -62,7 +62,7 @@ pub async fn outdated( let top_level_deps = find_top_level_deps(&factory, Some(jsr_resolver.clone())).await?; - eprintln!("top_level_deps {:#?}", top_level_deps); + // eprintln!("top_level_deps {:#?}", top_level_deps); let mut outdated_packages = vec![]; @@ -119,14 +119,14 @@ pub async fn outdated( continue; }; - eprintln!( - "wanted_package_and_version {:#?}", - wanted_package_and_version - ); - eprintln!( - "latest_package_and_version {:#?}", - latest_package_and_version - ); + // eprintln!( + // "wanted_package_and_version {:#?}", + // wanted_package_and_version + // ); + // eprintln!( + // "latest_package_and_version {:#?}", + // latest_package_and_version + // ); // if wanted_package_and_version == latest_package_and_version { // continue; // }