mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 15:24:46 -05:00
ce7dc2be92
Adds support for running npm package lifecycle scripts, opted into via a new `--allow-scripts` flag. With this PR, when running `deno cache` (or `DENO_FUTURE=1 deno install`) you can specify the `--allow-scripts=pkg1,pkg2` flag to run lifecycle scripts attached to the given packages. Note at the moment this only works when `nodeModulesDir` is true (using the local resolver). When a package with un-run lifecycle scripts is encountered, we emit a warning suggesting things may not work and to try running lifecycle scripts. Additionally, if a package script implicitly requires `node-gyp` and it's not found on the system, we emit a warning. Extra things in this PR: - Extracted out bits of `task.rs` into a separate module for reuse - Added a couple fields to `process.config` in order to support `node-gyp` (it relies on a few variables being there) - Drive by fix to downloading new npm packages to test registry --- TODO: - [x] validation for allow-scripts args (make sure it looks like an npm package) - [x] make allow-scripts matching smarter - [ ] figure out what issues this closes --- Review notes: - This adds a bunch of deps to our test registry due to using `node-gyp`, so it's pretty noisy
333 lines
9 KiB
Rust
333 lines
9 KiB
Rust
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
|
|
use crate::npm::managed::NpmResolutionPackage;
|
|
use deno_core::anyhow::Context;
|
|
use deno_core::error::AnyError;
|
|
use deno_npm::resolution::NpmResolutionSnapshot;
|
|
use deno_npm::NpmPackageId;
|
|
use std::collections::HashMap;
|
|
use std::collections::HashSet;
|
|
use std::collections::VecDeque;
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct BinEntries {
|
|
/// Packages that have colliding bin names
|
|
collisions: HashSet<NpmPackageId>,
|
|
seen_names: HashMap<String, NpmPackageId>,
|
|
/// The bin entries
|
|
entries: Vec<(NpmResolutionPackage, PathBuf)>,
|
|
}
|
|
|
|
/// Returns the name of the default binary for the given package.
|
|
/// This is the package name without the organization (`@org/`), if any.
|
|
fn default_bin_name(package: &NpmResolutionPackage) -> &str {
|
|
package
|
|
.id
|
|
.nv
|
|
.name
|
|
.rsplit_once('/')
|
|
.map_or(package.id.nv.name.as_str(), |(_, name)| name)
|
|
}
|
|
|
|
impl BinEntries {
|
|
pub(super) fn new() -> Self {
|
|
Self::default()
|
|
}
|
|
|
|
/// Add a new bin entry (package with a bin field)
|
|
pub(super) fn add(
|
|
&mut self,
|
|
package: NpmResolutionPackage,
|
|
package_path: PathBuf,
|
|
) {
|
|
// check for a new collision, if we haven't already
|
|
// found one
|
|
match package.bin.as_ref().unwrap() {
|
|
deno_npm::registry::NpmPackageVersionBinEntry::String(_) => {
|
|
let bin_name = default_bin_name(&package);
|
|
|
|
if let Some(other) = self
|
|
.seen_names
|
|
.insert(bin_name.to_string(), package.id.clone())
|
|
{
|
|
self.collisions.insert(package.id.clone());
|
|
self.collisions.insert(other);
|
|
}
|
|
}
|
|
deno_npm::registry::NpmPackageVersionBinEntry::Map(entries) => {
|
|
for name in entries.keys() {
|
|
if let Some(other) =
|
|
self.seen_names.insert(name.to_string(), package.id.clone())
|
|
{
|
|
self.collisions.insert(package.id.clone());
|
|
self.collisions.insert(other);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
self.entries.push((package, package_path));
|
|
}
|
|
|
|
fn for_each_entry(
|
|
&mut self,
|
|
snapshot: &NpmResolutionSnapshot,
|
|
mut f: impl FnMut(
|
|
&NpmResolutionPackage,
|
|
&Path,
|
|
&str, // bin name
|
|
&str, // bin script
|
|
) -> Result<(), AnyError>,
|
|
) -> Result<(), AnyError> {
|
|
if !self.collisions.is_empty() {
|
|
// walking the dependency tree to find out the depth of each package
|
|
// is sort of expensive, so we only do it if there's a collision
|
|
sort_by_depth(snapshot, &mut self.entries, &mut self.collisions);
|
|
}
|
|
|
|
let mut seen = HashSet::new();
|
|
|
|
for (package, package_path) in &self.entries {
|
|
if let Some(bin_entries) = &package.bin {
|
|
match bin_entries {
|
|
deno_npm::registry::NpmPackageVersionBinEntry::String(script) => {
|
|
let name = default_bin_name(package);
|
|
if !seen.insert(name) {
|
|
// we already set up a bin entry with this name
|
|
continue;
|
|
}
|
|
f(package, package_path, name, script)?;
|
|
}
|
|
deno_npm::registry::NpmPackageVersionBinEntry::Map(entries) => {
|
|
for (name, script) in entries {
|
|
if !seen.insert(name) {
|
|
// we already set up a bin entry with this name
|
|
continue;
|
|
}
|
|
f(package, package_path, name, script)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Collect the bin entries into a vec of (name, script path)
|
|
pub(super) fn into_bin_files(
|
|
mut self,
|
|
snapshot: &NpmResolutionSnapshot,
|
|
) -> Vec<(String, PathBuf)> {
|
|
let mut bins = Vec::new();
|
|
self
|
|
.for_each_entry(snapshot, |_, package_path, name, script| {
|
|
bins.push((name.to_string(), package_path.join(script)));
|
|
Ok(())
|
|
})
|
|
.unwrap();
|
|
bins
|
|
}
|
|
|
|
/// Finish setting up the bin entries, writing the necessary files
|
|
/// to disk.
|
|
pub(super) fn finish(
|
|
mut self,
|
|
snapshot: &NpmResolutionSnapshot,
|
|
bin_node_modules_dir_path: &Path,
|
|
) -> Result<(), AnyError> {
|
|
if !self.entries.is_empty() && !bin_node_modules_dir_path.exists() {
|
|
std::fs::create_dir_all(bin_node_modules_dir_path).with_context(
|
|
|| format!("Creating '{}'", bin_node_modules_dir_path.display()),
|
|
)?;
|
|
}
|
|
|
|
self.for_each_entry(snapshot, |package, package_path, name, script| {
|
|
set_up_bin_entry(
|
|
package,
|
|
name,
|
|
script,
|
|
package_path,
|
|
bin_node_modules_dir_path,
|
|
)
|
|
})?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// walk the dependency tree to find out the depth of each package
|
|
// that has a bin entry, then sort them by depth
|
|
fn sort_by_depth(
|
|
snapshot: &NpmResolutionSnapshot,
|
|
bin_entries: &mut [(NpmResolutionPackage, PathBuf)],
|
|
collisions: &mut HashSet<NpmPackageId>,
|
|
) {
|
|
enum Entry<'a> {
|
|
Pkg(&'a NpmPackageId),
|
|
IncreaseDepth,
|
|
}
|
|
|
|
let mut seen = HashSet::new();
|
|
let mut depths: HashMap<&NpmPackageId, u64> =
|
|
HashMap::with_capacity(collisions.len());
|
|
|
|
let mut queue = VecDeque::new();
|
|
queue.extend(snapshot.top_level_packages().map(Entry::Pkg));
|
|
seen.extend(snapshot.top_level_packages());
|
|
queue.push_back(Entry::IncreaseDepth);
|
|
|
|
let mut current_depth = 0u64;
|
|
|
|
while let Some(entry) = queue.pop_front() {
|
|
if collisions.is_empty() {
|
|
break;
|
|
}
|
|
let id = match entry {
|
|
Entry::Pkg(id) => id,
|
|
Entry::IncreaseDepth => {
|
|
current_depth += 1;
|
|
if queue.is_empty() {
|
|
break;
|
|
}
|
|
queue.push_back(Entry::IncreaseDepth);
|
|
continue;
|
|
}
|
|
};
|
|
if let Some(package) = snapshot.package_from_id(id) {
|
|
if collisions.remove(&package.id) {
|
|
depths.insert(&package.id, current_depth);
|
|
}
|
|
for dep in package.dependencies.values() {
|
|
if seen.insert(dep) {
|
|
queue.push_back(Entry::Pkg(dep));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bin_entries.sort_by(|(a, _), (b, _)| {
|
|
depths
|
|
.get(&a.id)
|
|
.unwrap_or(&u64::MAX)
|
|
.cmp(depths.get(&b.id).unwrap_or(&u64::MAX))
|
|
.then_with(|| a.id.nv.cmp(&b.id.nv).reverse())
|
|
});
|
|
}
|
|
|
|
pub(super) fn set_up_bin_entry(
|
|
package: &NpmResolutionPackage,
|
|
bin_name: &str,
|
|
#[allow(unused_variables)] bin_script: &str,
|
|
#[allow(unused_variables)] package_path: &Path,
|
|
bin_node_modules_dir_path: &Path,
|
|
) -> Result<(), AnyError> {
|
|
#[cfg(windows)]
|
|
{
|
|
set_up_bin_shim(package, bin_name, bin_node_modules_dir_path)?;
|
|
}
|
|
#[cfg(unix)]
|
|
{
|
|
symlink_bin_entry(
|
|
package,
|
|
bin_name,
|
|
bin_script,
|
|
package_path,
|
|
bin_node_modules_dir_path,
|
|
)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
fn set_up_bin_shim(
|
|
package: &NpmResolutionPackage,
|
|
bin_name: &str,
|
|
bin_node_modules_dir_path: &Path,
|
|
) -> Result<(), AnyError> {
|
|
use std::fs;
|
|
let mut cmd_shim = bin_node_modules_dir_path.join(bin_name);
|
|
|
|
cmd_shim.set_extension("cmd");
|
|
let shim = format!("@deno run -A npm:{}/{bin_name} %*", package.id.nv);
|
|
fs::write(&cmd_shim, shim).with_context(|| {
|
|
format!("Can't set up '{}' bin at {}", bin_name, cmd_shim.display())
|
|
})?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn symlink_bin_entry(
|
|
_package: &NpmResolutionPackage,
|
|
bin_name: &str,
|
|
bin_script: &str,
|
|
package_path: &Path,
|
|
bin_node_modules_dir_path: &Path,
|
|
) -> Result<(), AnyError> {
|
|
use std::io;
|
|
use std::os::unix::fs::symlink;
|
|
let link = bin_node_modules_dir_path.join(bin_name);
|
|
let original = package_path.join(bin_script);
|
|
|
|
use std::os::unix::fs::PermissionsExt;
|
|
let mut perms = match std::fs::metadata(&original) {
|
|
Ok(metadata) => metadata.permissions(),
|
|
Err(err) => {
|
|
if err.kind() == io::ErrorKind::NotFound {
|
|
log::warn!(
|
|
"{} Trying to set up '{}' bin for \"{}\", but the entry point \"{}\" doesn't exist.",
|
|
deno_terminal::colors::yellow("Warning"),
|
|
bin_name,
|
|
package_path.display(),
|
|
original.display()
|
|
);
|
|
return Ok(());
|
|
}
|
|
return Err(err).with_context(|| {
|
|
format!("Can't set up '{}' bin at {}", bin_name, original.display())
|
|
});
|
|
}
|
|
};
|
|
if perms.mode() & 0o111 == 0 {
|
|
// if the original file is not executable, make it executable
|
|
perms.set_mode(perms.mode() | 0o111);
|
|
std::fs::set_permissions(&original, perms).with_context(|| {
|
|
format!("Setting permissions on '{}'", original.display())
|
|
})?;
|
|
}
|
|
let original_relative =
|
|
crate::util::path::relative_path(bin_node_modules_dir_path, &original)
|
|
.unwrap_or(original);
|
|
|
|
if let Err(err) = symlink(&original_relative, &link) {
|
|
if err.kind() == io::ErrorKind::AlreadyExists {
|
|
// remove and retry
|
|
std::fs::remove_file(&link).with_context(|| {
|
|
format!(
|
|
"Failed to remove existing bin symlink at {}",
|
|
link.display()
|
|
)
|
|
})?;
|
|
symlink(&original_relative, &link).with_context(|| {
|
|
format!(
|
|
"Can't set up '{}' bin at {}",
|
|
bin_name,
|
|
original_relative.display()
|
|
)
|
|
})?;
|
|
return Ok(());
|
|
}
|
|
return Err(err).with_context(|| {
|
|
format!(
|
|
"Can't set up '{}' bin at {}",
|
|
bin_name,
|
|
original_relative.display()
|
|
)
|
|
});
|
|
}
|
|
|
|
Ok(())
|
|
}
|