fix(npm): run workspace package lifecycle scripts (#34615)

## Summary
- Collect `package.json` workspace members as lifecycle-capable install
roots, including members without a package `name`/`version`.
- Register those workspace packages with the existing lifecycle script
runner for both isolated and hoisted `node_modules` layouts.
- Order workspace lifecycle scripts so transitive dependencies running
*through* non-script workspace packages are still executed before their
scripted dependents (addresses review feedback).
- Add a regression spec for a workspace member `postinstall` script
writing a file, including a script package depending through a
non-script workspace package onto another script package.

## Verification
- CI is green on this PR head (build + integration + node_compat across
all platforms).
- `cargo check -p deno_npm_installer`

Closes #25416

Closes denoland/divybot#364

---------

Co-authored-by: divybot <divybot@users.noreply.github.com>
Co-authored-by: Divy Srivastava <me@littledivy.com>

Author: divybot

cli/npm.rs

@@ -417,6 +417,7 @@ impl LifecycleScriptsExecutor for DenoTaskLifeCycleScriptsExecutor {
     let layers = compute_lifecycle_script_layers(
       options.packages_with_scripts,
       options.snapshot,
+      options.additional_packages,
     );
 
     for layer in &layers {
@@ -547,6 +548,7 @@ impl DenoTaskLifeCycleScriptsExecutor {
         base_custom_commands.clone(),
         package,
         options.snapshot,
+        options.additional_packages,
       )
       .await;
 
@@ -727,6 +729,7 @@ impl DenoTaskLifeCycleScriptsExecutor {
     baseline: crate::task_runner::TaskCustomCommands,
     package: &NpmResolutionPackage,
     snapshot: &NpmResolutionSnapshot,
+    additional_packages: &[&NpmResolutionPackage],
   ) -> crate::task_runner::TaskCustomCommands {
     let sys = CliSys::default();
     let mut bin_entries = BinEntries::new(sys.with_paths_in_errors());
@@ -737,7 +740,12 @@ impl DenoTaskLifeCycleScriptsExecutor {
         baseline,
         snapshot,
         package.dependencies.iter().filter_map(|(name, id)| {
-          let dep = snapshot.package_from_id(id).unwrap();
+          let dep = snapshot.package_from_id(id).or_else(|| {
+            additional_packages
+              .iter()
+              .find(|package| package.id == *id)
+              .copied()
+          })?;
           // Skip optional dependencies that don't match the current system
           if package.optional_dependencies.contains(name)
             && !dep.system.matches_system(&self.system_info)

libs/npm_installer/hoisted.rs

@@ -22,8 +22,11 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use deno_error::JsErrorBox;
+use deno_npm::NpmPackageExtraInfo;
 use deno_npm::NpmPackageId;
+use deno_npm::NpmPackageIdPeerDependencies;
 use deno_npm::NpmResolutionPackage;
+use deno_npm::NpmResolutionPackageSystemInfo;
 use deno_npm::NpmSystemInfo;
 use deno_npm::resolution::NpmResolutionSnapshot;
 use deno_npm_cache::NpmCache;
@@ -63,6 +66,7 @@ use crate::local::LocalNpmInstallSys;
 use crate::local::LocalNpmPackageInstallerOptions;
 use crate::local::SyncResolutionWithFsError;
 use crate::local::join_package_name;
+use crate::package_json::InstallWorkspacePkgDep;
 use crate::package_json::NpmInstallDepsProvider;
 use crate::process_state::NpmProcessState;
 
@@ -347,7 +351,12 @@ impl<
     snapshot: &NpmResolutionSnapshot,
   ) -> Result<(), SyncResolutionWithFsError> {
     let has_no_packages = snapshot.is_empty()
-      && self.npm_install_deps_provider.local_pkgs().is_empty();
+      && self.npm_install_deps_provider.local_pkgs().is_empty()
+      && !self
+        .npm_install_deps_provider
+        .workspace_pkgs()
+        .iter()
+        .any(|pkg| !pkg.scripts.is_empty());
     let deno_marker_dir = self.root_node_modules_path.join(".deno");
     if has_no_packages
       && (!self.clean_on_install
@@ -398,6 +407,8 @@ impl<
     }
 
     // 2. Clone all packages from cache into their hoisted positions
+    let workspace_lifecycle_packages =
+      self.resolve_workspace_lifecycle_packages(snapshot)?;
     let mut cache_futures = FuturesUnordered::new();
     let bin_entries = Rc::new(RefCell::new(BinEntries::new(sys)));
     let lifecycle_scripts = Rc::new(RefCell::new(LifecycleScripts::new(
@@ -538,6 +549,7 @@ impl<
     while let Some(result) = cache_futures.next().await {
       result?;
     }
+    drop(cache_futures);
 
     // 5. Set up bin entries
     {
@@ -582,6 +594,18 @@ impl<
       }
     }
 
+    for package in &workspace_lifecycle_packages {
+      lifecycle_scripts.borrow_mut().add(
+        &package.package,
+        &NpmPackageExtraInfo {
+          scripts: package.scripts.clone(),
+          ..Default::default()
+        },
+        Cow::Borrowed(&package.package_path),
+        Vec::new(),
+      );
+    }
+
     // Deprecation warnings
     {
       let packages_with_deprecation_warnings =
@@ -621,7 +645,7 @@ impl<
     }
 
     // Lifecycle scripts
-    let lifecycle_scripts = std::mem::replace(
+    let lifecycle_scripts_to_run = std::mem::replace(
       &mut *lifecycle_scripts.borrow_mut(),
       LifecycleScripts::new(
         sys.as_ref(),
@@ -631,10 +655,16 @@ impl<
         },
       ),
     );
-    lifecycle_scripts.warn_not_run_scripts()?;
+    drop(lifecycle_scripts);
+    lifecycle_scripts_to_run.warn_not_run_scripts()?;
 
-    let packages_with_scripts = lifecycle_scripts.packages_with_scripts();
+    let packages_with_scripts =
+      lifecycle_scripts_to_run.packages_with_scripts();
     if !packages_with_scripts.is_empty() {
+      let additional_packages = workspace_lifecycle_packages
+        .iter()
+        .map(|package| &package.package)
+        .collect::<Vec<_>>();
       let process_state = NpmProcessState::new_local(
         snapshot.as_valid_serialized(),
         &self.root_node_modules_path,
@@ -651,6 +681,7 @@ impl<
           on_ran_pkg_scripts: &|_pkg| Ok(()),
           snapshot,
           system_packages: &package_partitions.packages,
+          additional_packages: &additional_packages,
           packages_with_scripts,
           extra_info_provider: &extra_info_provider,
         })
@@ -664,6 +695,68 @@ impl<
     Ok(())
   }
 
+  fn resolve_workspace_lifecycle_packages(
+    &self,
+    snapshot: &NpmResolutionSnapshot,
+  ) -> Result<Vec<WorkspaceLifecyclePackage>, JsErrorBox> {
+    let workspace_pkgs = self.npm_install_deps_provider.workspace_pkgs();
+    let workspace_pkg_ids = workspace_pkgs
+      .iter()
+      .map(|pkg| {
+        (
+          pkg.nv.clone(),
+          NpmPackageId {
+            nv: pkg.nv.clone(),
+            peer_dependencies: NpmPackageIdPeerDependencies::from([]),
+          },
+        )
+      })
+      .collect::<HashMap<_, _>>();
+    let mut packages = Vec::with_capacity(workspace_pkgs.len());
+    for workspace_pkg in workspace_pkgs {
+      let mut dependencies = HashMap::with_capacity(workspace_pkg.deps.len());
+      for dep in &workspace_pkg.deps {
+        match dep {
+          InstallWorkspacePkgDep::Remote { alias, req } => {
+            if let Some(id) = resolve_remote_pkg_id(snapshot, req) {
+              dependencies.insert(alias.clone(), id);
+            }
+          }
+          InstallWorkspacePkgDep::Workspace { alias, nv } => {
+            if let Some(id) = workspace_pkg_ids.get(nv) {
+              dependencies.insert(alias.clone(), id.clone());
+            }
+          }
+        }
+      }
+      let id = workspace_pkg_ids
+        .get(&workspace_pkg.nv)
+        .expect("workspace package id should exist")
+        .clone();
+      packages.push(WorkspaceLifecyclePackage {
+        package: NpmResolutionPackage {
+          id,
+          copy_index: 0,
+          system: NpmResolutionPackageSystemInfo::default(),
+          dist: None,
+          dependencies,
+          optional_dependencies: Default::default(),
+          optional_peer_dependencies: Default::default(),
+          extra: Some(NpmPackageExtraInfo {
+            scripts: workspace_pkg.scripts.clone(),
+            ..Default::default()
+          }),
+          is_deprecated: false,
+          has_bin: false,
+          has_scripts: !workspace_pkg.scripts.is_empty(),
+        },
+        package_path: workspace_pkg.target_dir.clone(),
+        scripts: workspace_pkg.scripts.clone(),
+      });
+    }
+    Ok(packages)
+  }
+
   #[allow(
     clippy::too_many_arguments,
     reason = "many parameters needed for package cloning"
@@ -773,6 +866,23 @@ impl<
   }
 }
 
+struct WorkspaceLifecyclePackage {
+  package: NpmResolutionPackage,
+  package_path: PathBuf,
+  scripts: HashMap<deno_semver::SmallStackString, String>,
+}
+
+fn resolve_remote_pkg_id(
+  snapshot: &NpmResolutionSnapshot,
+  req: &deno_semver::package::PackageReq,
+) -> Option<NpmPackageId> {
+  match snapshot.resolve_pkg_from_pkg_req(req) {
+    Ok(pkg) => Some(pkg.id.clone()),
+    Err(_) if req.version_req.tag().is_some() => None,
+    Err(_) => snapshot.resolve_best_package_id(&req.name, &req.version_req),
+  }
+}
+
 fn cleanup_hoisted_packages(
   sys: &impl LocalNpmInstallSys,
   root_node_modules_path: &Path,