feat(lockfile): track JSR and npm dependencies in config file (denola…

…nd#22004)

See overview in denoland/deno_lockfile#13

Cargo.toml

@@ -48,7 +48,7 @@ deno_runtime = { version = "0.140.0", path = "./runtime" }
 napi_sym = { version = "0.62.0", path = "./cli/napi/sym" }
 deno_bench_util = { version = "0.126.0", path = "./bench_util" }
 test_util = { path = "./test_util" }
-deno_lockfile = "0.17.2"
+deno_lockfile = "0.18.0"
 deno_media_type = { version = "0.1.1", features = ["module_specifier"] }
 
 denokv_proto = "0.5.0"

cli/Cargo.toml

@@ -59,14 +59,14 @@ deno_config = "=0.8.1"
 deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] }
 deno_doc = { version = "=0.93.0", features = ["html"] }
 deno_emit = "=0.33.0"
-deno_graph = "=0.63.3"
+deno_graph = "=0.63.4"
 deno_lint = { version = "=0.53.0", features = ["docs"] }
 deno_lockfile.workspace = true
-deno_npm = "=0.15.3"
+deno_npm = "=0.16.0"
 deno_runtime = { workspace = true, features = ["include_js_files_for_snapshotting"] }
 deno_semver = "=0.5.4"
 deno_task_shell = "=0.14.3"
-eszip = "=0.57.0"
+eszip = "=0.58.0"
 napi_sym.workspace = true
 
 async-trait.workspace = true

cli/args/mod.rs

@@ -1344,6 +1344,10 @@ impl CliOptions {
  self.flags.no_npm
  }
 
+ pub fn no_config(&self) -> bool {
+ self.flags.config_flag == deno_config::ConfigFlag::Disabled
+ }
+
  pub fn permissions_options(&self) -> PermissionsOptions {
  PermissionsOptions {
  allow_env: self.flags.allow_env.clone(),

cli/args/package_json.rs

@@ -6,7 +6,6 @@ use std::path::PathBuf;
 use deno_core::anyhow::bail;
 use deno_core::error::AnyError;
 use deno_npm::registry::parse_dep_entry_name_and_raw_version;
-use deno_npm::registry::PackageDepNpmSchemeValueParseError;
 use deno_runtime::deno_node::PackageJson;
 use deno_semver::package::PackageReq;
 use deno_semver::VersionReq;
@@ -16,8 +15,6 @@ use thiserror::Error;
 
 #[derive(Debug, Error, Clone)]
 pub enum PackageJsonDepValueParseError {
- #[error(transparent)]
- SchemeValue(#[from] PackageDepNpmSchemeValueParseError),
  #[error(transparent)]
  Specifier(#[from] VersionReqSpecifierParseError),
  #[error("Not implemented scheme '{scheme}'")]
@@ -39,17 +36,17 @@ impl PackageJsonDepsProvider {
  self.0.as_ref()
  }
 
- pub fn reqs(&self) -> Vec<&PackageReq> {
+ pub fn reqs(&self) -> Option<Vec<&PackageReq>> {
  match &self.0 {
  Some(deps) => {
  let mut package_reqs = deps
  .values()
  .filter_map(|r| r.as_ref().ok())
  .collect::<Vec<_>>();
  package_reqs.sort(); // deterministic resolution
- package_reqs
+ Some(package_reqs)
  }
- None => Vec::new(),
+ None => None,
  }
  }
 }
@@ -77,9 +74,7 @@ pub fn get_local_package_json_version_reqs(
  scheme: value.split(':').next().unwrap().to_string(),
  });
  }
- let (name, version_req) = parse_dep_entry_name_and_raw_version(key, value)
- .map_err(PackageJsonDepValueParseError::SchemeValue)?;
-
+ let (name, version_req) = parse_dep_entry_name_and_raw_version(key, value);
  let result = VersionReq::parse_from_specifier(version_req);
  match result {
  Ok(version_req) => Ok(PackageReq {
@@ -159,27 +154,6 @@ mod test {
 
  use super::*;
 
- #[test]
- fn test_parse_dep_entry_name_and_raw_version() {
- let cases = [
- ("test", "^1.2", Ok(("test", "^1.2"))),
- ("test", "1.x - 2.6", Ok(("test", "1.x - 2.6"))),
- ("test", "npm:package@^1.2", Ok(("package", "^1.2"))),
- (
- "test",
- "npm:package",
- Err("Could not find @ symbol in npm url 'npm:package'"),
- ),
- ];
- for (key, value, expected_result) in cases {
- let result = parse_dep_entry_name_and_raw_version(key, value);
- match result {
- Ok(result) => assert_eq!(result, expected_result.unwrap()),
- Err(err) => assert_eq!(err.to_string(), expected_result.err().unwrap()),
- }
- }
- }
-
  fn get_local_package_json_version_reqs_for_tests(
  package_json: &PackageJson,
  ) -> IndexMap<String, Result<PackageReq, String>> {

cli/factory.rs

@@ -44,6 +44,8 @@ use crate::standalone::DenoCompileBinaryWriter;
 use crate::tools::check::TypeChecker;
 use crate::util::file_watcher::WatcherCommunicator;
 use crate::util::fs::canonicalize_path_maybe_not_exists;
+use crate::util::import_map::deno_json_deps;
+use crate::util::import_map::import_map_deps;
 use crate::util::progress_bar::ProgressBar;
 use crate::util::progress_bar::ProgressBarStyle;
 use crate::worker::CliMainWorkerFactory;
@@ -54,12 +56,14 @@ use deno_core::parking_lot::Mutex;
 use deno_core::FeatureChecker;
 
 use deno_graph::GraphKind;
+use deno_lockfile::WorkspaceMemberConfig;
 use deno_runtime::deno_fs;
 use deno_runtime::deno_node::analyze::NodeCodeTranslator;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_tls::RootCertStoreProvider;
 use deno_runtime::deno_web::BlobStore;
 use deno_runtime::inspector_server::InspectorServer;
+use deno_semver::package::PackageNv;
 use import_map::ImportMap;
 use log::warn;
 use std::future::Future;
@@ -289,10 +293,84 @@ impl CliFactory {
  }
 
  pub fn maybe_lockfile(&self) -> &Option<Arc<Mutex<Lockfile>>> {
- self
- .services
- .lockfile
- .get_or_init(|| self.options.maybe_lockfile())
+ self.services.lockfile.get_or_init(|| {
+ let maybe_lockfile = self.options.maybe_lockfile();
+
+ // initialize the lockfile with the workspace's configuration
+ if let Some(lockfile) = &maybe_lockfile {
+ let package_json_deps = self
+ .package_json_deps_provider()
+ .reqs()
+ .map(|reqs| reqs.into_iter().map(|s| format!("npm:{}", s)).collect())
+ .unwrap_or_default();
+ let mut lockfile = lockfile.lock();
+ let config = match self.options.maybe_workspace_config() {
+ Some(workspace_config) => deno_lockfile::WorkspaceConfig {
+ root: WorkspaceMemberConfig {
+ package_json_deps,
+ dependencies: import_map_deps(
+ &workspace_config.base_import_map_value,
+ )
+ .into_iter()
+ .map(|req| req.to_string())
+ .collect(),
+ },
+ members: workspace_config
+ .members
+ .iter()
+ .map(|member| {
+ (
+ member.package_name.clone(),
+ WorkspaceMemberConfig {
+ package_json_deps: Default::default(),
+ dependencies: deno_json_deps(&member.config_file)
+ .into_iter()
+ .map(|req| req.to_string())
+ .collect(),
+ },
+ )
+ })
+ .collect(),
+ },
+ None => deno_lockfile::WorkspaceConfig {
+ root: WorkspaceMemberConfig {
+ package_json_deps,
+ dependencies: self
+ .options
+ .maybe_config_file()
+ .as_ref()
+ .map(|config| {
+ deno_json_deps(config)
+ .into_iter()
+ .map(|req| req.to_string())
+ .collect()
+ })
+ .unwrap_or_default(),
+ },
+ members: Default::default(),
+ },
+ };
+ lockfile.set_workspace_config(
+ deno_lockfile::SetWorkspaceConfigOptions {
+ no_npm: self.options.no_npm(),
+ no_config: self.options.no_config(),
+ config,
+ nv_to_jsr_url: |nv| {
+ let nv = PackageNv::from_str(nv).ok()?;
+ Some(
+ deno_graph::source::recommended_registry_package_url(
+ crate::args::deno_registry_url(),
+ &nv,
+ )
+ .to_string(),
+ )
+ },
+ },
+ );
+ }
+
+ maybe_lockfile
+ })
  }
 
  pub async fn npm_resolver(
@@ -320,7 +398,7 @@ impl CliFactory {
  Some(snapshot) => {
  CliNpmResolverManagedSnapshotOption::Specified(Some(snapshot))
  }
- None => match self.maybe_lockfile() {
+ None => match self.maybe_lockfile().as_ref() {
  Some(lockfile) => {
  CliNpmResolverManagedSnapshotOption::ResolveFromLockfile(
  lockfile.clone(),

cli/graph_util.rs

@@ -504,6 +504,10 @@ impl ModuleGraphBuilder {
  format!("jsr:{}", to),
  );
  }
+ for (name, deps) in graph.packages.package_deps() {
+ lockfile
+ .insert_package_deps(name.to_string(), deps.map(|s| s.to_string()));
+ }
  }
  }
 

cli/main.rs

@@ -38,6 +38,7 @@ use deno_core::error::AnyError;
 use deno_core::error::JsError;
 use deno_core::futures::FutureExt;
 use deno_core::unsync::JoinHandle;
+use deno_npm::resolution::SnapshotFromLockfileError;
 use deno_runtime::colors;
 use deno_runtime::fmt_errors::format_js_error;
 use deno_runtime::tokio_util::create_and_run_current_thread_with_maybe_metrics;
@@ -261,7 +262,14 @@ fn unwrap_or_exit<T>(result: Result<T, AnyError>) -> T {
 
  if let Some(e) = error.downcast_ref::<JsError>() {
  error_string = format_js_error(e);
- } else if let Some(e) = error.downcast_ref::<args::LockfileError>() {
+ } else if let Some(args::LockfileError::IntegrityCheckFailed(e)) =
+ error.downcast_ref::<args::LockfileError>()
+ {
+ error_string = e.to_string();
+ error_code = 10;
+ } else if let Some(SnapshotFromLockfileError::IntegrityCheckFailed(e)) =
+ error.downcast_ref::<SnapshotFromLockfileError>()
+ {
  error_string = e.to_string();
  error_code = 10;
  }

cli/npm/managed/installer.rs

@@ -82,7 +82,7 @@ impl PackageJsonDepsInstaller {
  return Ok(()); // already installed by something else
  }
 
- let package_reqs = inner.deps_provider.reqs();
+ let package_reqs = inner.deps_provider.reqs().unwrap_or_default();
 
  // check if something needs resolving before bothering to load all
  // the package information (which is slow)