use crate::{
graph::{DependencyGraph, DependencyGraphNode},
manifest::{overrides::OverrideSpecifier, Alias, DependencyType},
source::{
ids::PackageId,
pesde::PesdePackageSource,
specifiers::DependencySpecifiers,
traits::{PackageRef as _, PackageSource as _, RefreshOptions, ResolveOptions},
PackageSources,
},
Project, RefreshedSources,
};
use std::collections::{btree_map::Entry, HashMap, VecDeque};
use tracing::{instrument, Instrument as _};
fn insert_node(
graph: &mut DependencyGraph,
package_id: &PackageId,
mut node: DependencyGraphNode,
is_top_level: bool,
) {
if !is_top_level && node.direct.take().is_some() {
tracing::debug!(
"tried to insert {package_id} as direct dependency from a non top-level context",
);
}
match graph.entry(package_id.clone()) {
Entry::Vacant(entry) => {
entry.insert(node);
}
Entry::Occupied(existing) => {
let current_node = existing.into_mut();
match (¤t_node.direct, &node.direct) {
(Some(_), Some(_)) => {
tracing::warn!("duplicate direct dependency for {package_id}");
}
(None, Some(_)) => {
current_node.direct = node.direct;
}
(_, _) => {}
}
}
}
}
impl Project {
#[instrument(
skip(self, previous_graph, refreshed_sources),
ret(level = "trace"),
level = "debug"
)]
pub async fn dependency_graph(
&self,
previous_graph: Option<&DependencyGraph>,
refreshed_sources: RefreshedSources,
is_published_package: bool,
) -> Result<DependencyGraph, Box<errors::DependencyGraphError>> {
let manifest = self
.deser_manifest()
.await
.map_err(|e| Box::new(e.into()))?;
let all_current_dependencies = manifest
.all_dependencies()
.map_err(|e| Box::new(e.into()))?;
let mut all_specifiers = all_current_dependencies
.clone()
.into_iter()
.map(|(alias, (spec, ty))| ((spec, ty), alias))
.collect::<HashMap<_, _>>();
let mut graph = DependencyGraph::default();
if let Some(previous_graph) = previous_graph {
for (package_id, node) in previous_graph {
let Some((old_alias, specifier, source_ty)) = &node.direct else {
continue;
};
if specifier.is_local() {
continue;
}
let Some(alias) = all_specifiers.remove(&(specifier.clone(), *source_ty)) else {
tracing::debug!(
"dependency {package_id} (old alias {old_alias}) from old dependency graph is no longer in the manifest",
);
continue;
};
let span = tracing::info_span!("resolve from old graph", alias = alias.as_str());
let _guard = span.enter();
tracing::debug!("resolved {package_id} from old dependency graph");
insert_node(
&mut graph,
package_id,
DependencyGraphNode {
direct: Some((alias.clone(), specifier.clone(), *source_ty)),
..node.clone()
},
true,
);
let mut queue = node
.dependencies
.iter()
.map(|(dep_alias, (id, _))| {
(id, vec![alias.to_string(), dep_alias.to_string()])
})
.collect::<VecDeque<_>>();
while let Some((dep_id, path)) = queue.pop_front() {
let inner_span =
tracing::info_span!("resolve dependency", path = path.join(">"));
let _inner_guard = inner_span.enter();
if let Some(dep_node) = previous_graph.get(dep_id) {
tracing::debug!("resolved sub-dependency {dep_id}");
if graph.contains_key(dep_id) {
tracing::debug!(
"sub-dependency {dep_id} already resolved in new graph",
);
continue;
}
insert_node(&mut graph, dep_id, dep_node.clone(), false);
dep_node
.dependencies
.iter()
.map(|(alias, (id, _))| {
(
id,
path.iter()
.cloned()
.chain(std::iter::once(alias.to_string()))
.collect(),
)
})
.for_each(|dep| queue.push_back(dep));
} else {
tracing::warn!("dependency {dep_id} not found in previous graph");
}
}
}
}
let mut queue = all_specifiers
.into_iter()
.map(|((spec, ty), alias)| {
(
spec,
ty,
None::<PackageId>,
vec![alias],
false,
manifest.target.kind(),
)
})
.collect::<VecDeque<_>>();
let refresh_options = RefreshOptions {
project: self.clone(),
};
while let Some((specifier, ty, dependant, path, overridden, target)) = queue.pop_front() {
async {
let alias = path.last().unwrap();
let depth = path.len() - 1;
tracing::debug!("resolving {specifier} ({ty:?})");
let source = match &specifier {
DependencySpecifiers::Pesde(specifier) => {
let index_url = if !is_published_package && (depth == 0 || overridden) {
manifest
.indices
.get(&specifier.index)
.ok_or_else(|| errors::DependencyGraphError::IndexNotFound(
specifier.index.clone(),
))?
.clone()
} else {
specifier.index
.as_str()
.try_into()
.unwrap()
};
PackageSources::Pesde(PesdePackageSource::new(index_url))
}
#[cfg(feature = "wally-compat")]
DependencySpecifiers::Wally(specifier) => {
let index_url = if !is_published_package && (depth == 0 || overridden) {
manifest
.wally_indices
.get(&specifier.index)
.ok_or_else(|| errors::DependencyGraphError::WallyIndexNotFound(
specifier.index.clone(),
))?
.clone()
} else {
specifier.index
.as_str()
.try_into()
.unwrap()
};
PackageSources::Wally(crate::source::wally::WallyPackageSource::new(index_url))
}
DependencySpecifiers::Git(specifier) => PackageSources::Git(
crate::source::git::GitPackageSource::new(specifier.repo.clone()),
),
DependencySpecifiers::Workspace(_) => {
PackageSources::Workspace(crate::source::workspace::WorkspacePackageSource)
}
DependencySpecifiers::Path(_) => {
PackageSources::Path(crate::source::path::PathPackageSource)
}
};
refreshed_sources.refresh(
&source,
&refresh_options,
)
.await
.map_err(|e| Box::new(e.into()))?;
let (name, resolved, suggestions) = source
.resolve(&specifier, &ResolveOptions {
project: self.clone(),
target,
refreshed_sources: refreshed_sources.clone(),
loose_target: false,
})
.await
.map_err(|e| Box::new(e.into()))?;
let Some(package_id) = graph
.keys()
.filter(|id| *id.name() == name && resolved.contains_key(id.version_id()))
.max()
.cloned()
.or_else(|| resolved.last_key_value().map(|(ver, _)| PackageId::new(name, ver.clone())))
else {
return Err(Box::new(errors::DependencyGraphError::NoMatchingVersion(
format!(
"{specifier} {target}{}",
if suggestions.is_empty() {
"".into()
} else {
format!(
" available targets: {}",
suggestions
.into_iter()
.map(|t| t.to_string())
.collect::<Vec<_>>()
.join(", ")
)
}
),
)));
};
if let Some(dependant_id) = dependant {
graph
.get_mut(&dependant_id)
.expect("dependant package not found in graph")
.dependencies
.insert(alias.clone(), (package_id.clone(), ty));
}
let pkg_ref = &resolved[package_id.version_id()];
if let Some(already_resolved) = graph.get_mut(&package_id) {
tracing::debug!("{package_id} already resolved");
if std::mem::discriminant(&already_resolved.pkg_ref) != std::mem::discriminant(pkg_ref) {
tracing::warn!(
"resolved package {package_id} has a different source than previously resolved one, this may cause issues",
);
}
if already_resolved.direct.is_none() && depth == 0 {
already_resolved.direct = Some((alias.clone(), specifier.clone(), ty));
}
return Ok(());
}
let node = DependencyGraphNode {
direct: (depth == 0).then(|| (alias.clone(), specifier.clone(), ty)),
pkg_ref: pkg_ref.clone(),
dependencies: Default::default(),
};
insert_node(
&mut graph,
&package_id,
node,
depth == 0,
);
tracing::debug!("resolved {package_id} from new dependency graph");
for (dependency_alias, (dependency_spec, dependency_ty)) in
pkg_ref.dependencies().clone()
{
if dependency_ty == DependencyType::Dev {
continue;
}
let overridden = manifest.overrides.iter().find_map(|(key, spec)| {
key.0.iter().find_map(|override_path| {
(path.len() == override_path.len() - 1
&& path == override_path[..override_path.len() - 1]
&& override_path.last() == Some(&dependency_alias))
.then_some(spec)
})
});
if overridden.is_some() {
tracing::debug!(
"overridden specifier found for {} ({dependency_spec})",
path.iter()
.map(Alias::as_str)
.chain(std::iter::once(dependency_alias.as_str()))
.collect::<Vec<_>>()
.join(">"),
);
}
queue.push_back((
match overridden {
Some(OverrideSpecifier::Specifier(spec)) => spec.clone(),
Some(OverrideSpecifier::Alias(alias)) => all_current_dependencies.get(alias)
.map(|(spec, _)| spec)
.ok_or_else(|| errors::DependencyGraphError::AliasNotFound(alias.clone()))?
.clone(),
None => dependency_spec,
},
dependency_ty,
Some(package_id.clone()),
path.iter()
.cloned()
.chain(std::iter::once(dependency_alias))
.collect(),
overridden.is_some(),
package_id.version_id().target(),
));
}
Ok(())
}
.instrument(tracing::info_span!("resolve new/changed", path = path.iter().map(Alias::as_str).collect::<Vec<_>>().join(">")))
.await?;
}
Ok(graph)
}
}
pub mod errors {
use crate::manifest::Alias;
use thiserror::Error;
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum DependencyGraphError {
#[error("failed to deserialize manifest")]
ManifestRead(#[from] crate::errors::ManifestReadError),
#[error("error getting all project dependencies")]
AllDependencies(#[from] crate::manifest::errors::AllDependenciesError),
#[error("index named `{0}` not found in manifest")]
IndexNotFound(String),
#[cfg(feature = "wally-compat")]
#[error("wally index named `{0}` not found in manifest")]
WallyIndexNotFound(String),
#[error("error refreshing package source")]
Refresh(#[from] crate::source::errors::RefreshError),
#[error("error resolving package")]
Resolve(#[from] crate::source::errors::ResolveError),
#[error("no matching version found for {0}")]
NoMatchingVersion(String),
#[error("alias `{0}` not found in manifest")]
AliasNotFound(Alias),
}
}