Completed task hashing

crates/turborepo-lib/src/hash/mod.rs

@@ -13,7 +13,7 @@ use serde::Serialize;
 pub use traits::TurboHash;
 use turborepo_env::ResolvedEnvMode;
 
-use crate::cli::EnvMode;
+use crate::{cli::EnvMode, task_graph::TaskOutputs};
 
 mod proto_capnp {
  use turborepo_env::ResolvedEnvMode;
@@ -42,25 +42,25 @@ mod proto_capnp {
  }
 }
 
-pub struct TaskHashable {
+pub struct TaskHashable<'a> {
  // hashes
- global_hash: String,
- task_dependency_hashes: Vec<String>,
- hash_of_files: String,
- external_deps_hash: String,
+ pub(crate) global_hash: &'a str,
+ pub(crate) task_dependency_hashes: Vec<&'a String>,
+ pub(crate) hash_of_files: &'a str,
+ pub(crate) external_deps_hash: String,
 
  // task
- package_dir: turbopath::RelativeUnixPathBuf,
- task: String,
- outputs: TaskOutputs,
- pass_thru_args: Vec<String>,
+ pub(crate) package_dir: turbopath::RelativeUnixPathBuf,
+ pub(crate) task: &'a str,
+ pub(crate) outputs: TaskOutputs,
+ pub(crate) pass_through_args: &'a [String],
 
  // env
- env: Vec<String>,
- resolved_env_vars: EnvVarPairs,
- pub(crate) pass_through_env: Vec<String>,
+ pub(crate) env: &'a [String],
+ pub(crate) resolved_env_vars: EnvVarPairs,
+ pub(crate) pass_through_env: &'a [String],
  pub(crate) env_mode: ResolvedEnvMode,
- dot_env: Vec<turbopath::RelativeUnixPathBuf>,
+ pub(crate) dot_env: &'a [turbopath::RelativeUnixPathBuf],
 }
 
 #[derive(Debug)]
@@ -76,11 +76,6 @@ pub struct GlobalHashable<'a> {
  pub dot_env: &'a [turbopath::RelativeUnixPathBuf],
 }
 
-struct TaskOutputs {
- inclusions: Vec<String>,
- exclusions: Vec<String>,
-}
-
 pub struct LockFilePackages(pub Vec<turborepo_lockfiles::Package>);
 
 #[derive(Debug, Clone, Serialize)]
@@ -198,7 +193,7 @@ impl From<FileHashes> for Builder<HeapAllocator> {
 
 type EnvVarPairs = Vec<String>;
 
-impl From<TaskHashable> for Builder<HeapAllocator> {
+impl From<TaskHashable<'_>> for Builder<HeapAllocator> {
  fn from(task_hashable: TaskHashable) -> Self {
  let mut message =
  ::capnp::message::TypedBuilder::<proto_capnp::task_hashable::Owned>::new_default();
@@ -230,8 +225,8 @@ impl From<TaskHashable> for Builder<HeapAllocator> {
  {
  let mut pass_thru_args_builder = builder
  .reborrow()
- .init_pass_thru_args(task_hashable.pass_thru_args.len() as u32);
- for (i, arg) in task_hashable.pass_thru_args.iter().enumerate() {
+ .init_pass_thru_args(task_hashable.pass_through_args.len() as u32);
+ for (i, arg) in task_hashable.pass_through_args.iter().enumerate() {
  pass_thru_args_builder.set(i as u32, arg);
  }
  }
@@ -399,7 +394,7 @@ mod test {
  inclusions: vec!["inclusions".to_string()],
  exclusions: vec!["exclusions".to_string()],
  },
- pass_thru_args: vec!["pass_thru_args".to_string()],
+ pass_through_args: vec!["pass_thru_args".to_string()],
  env: vec!["env".to_string()],
  resolved_env_vars: vec![],
  pass_through_env: vec!["pass_thru_env".to_string()],

crates/turborepo-lib/src/package_graph/builder.rs

@@ -183,19 +183,12 @@ impl<'a> BuildState<'a, ResolvedPackageManager> {
  ) -> Result<(), Error> {
  let relative_json_path =
  AnchoredSystemPathBuf::relative_path_between(self.repo_root, &package_json_path);
-<<<<<<< HEAD
  let name = WorkspaceName::Other(
  json.name
  .clone()
  .ok_or(Error::PackageJsonMissingName(package_json_path))?,
  );
-=======
- let name = WorkspaceName::Other(json.name.clone().ok_or_else(|| {
- Error::PackageJsonMissingName {
- path: package_json_path,
- }
- })?);
->>>>>>> 8c3242ddf (Fixes)
+
  let entry = WorkspaceInfo {
  package_json: json,
  package_json_path: relative_json_path,

crates/turborepo-lib/src/package_graph/mod.rs

@@ -15,6 +15,8 @@ mod builder;
 
 pub use builder::{Error, PackageGraphBuilder};
 
+use crate::hash::{LockFilePackages, TurboHash};
+
 pub struct PackageGraph {
  workspace_graph: petgraph::Graph<WorkspaceNode, ()>,
  #[allow(dead_code)]
@@ -36,6 +38,31 @@ impl WorkspaceInfo {
  pub fn package_json_path(&self) -> &AnchoredSystemPathBuf {
  &self.package_json_path
  }
+
+ /// The directory of the workspace (computed from package.json path)
+ pub fn dir(&self) -> &AnchoredSystemPath {
+ self.package_json_path
+ .parent()
+ .unwrap_or_else(|| AnchoredSystemPath::new("").unwrap())
+ }
+
+ pub fn get_external_deps_hash(&self) -> String {
+ let mut transitive_deps = Vec::with_capacity(
+ self.transitive_dependencies
+ .as_ref()
+ .map_or(0, |deps| deps.len()),
+ );
+ for dependency in self.transitive_dependencies.iter().flatten() {
+ transitive_deps.push(dependency.clone());
+ }
+
+ transitive_deps.sort_by(|a, b| match a.key.cmp(&b.key) {
+ std::cmp::Ordering::Equal => a.version.cmp(&b.version),
+ other => other,
+ });
+
+ LockFilePackages(transitive_deps).hash()
+ }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]

crates/turborepo-lib/src/run/global_hash.rs

@@ -12,6 +12,7 @@ use turborepo_scm::SCM;
 use crate::{
  cli::EnvMode,
  hash::{GlobalHashable, TurboHash},
+ package_graph::WorkspaceInfo,
  package_json::PackageJson,
  package_manager::PackageManager,
 };
@@ -41,9 +42,8 @@ pub struct GlobalHashableInputs<'a> {
 
 #[allow(clippy::too_many_arguments)]
 pub fn get_global_hash_inputs<'a, L: ?Sized + Lockfile>(
- root_external_dependencies: HashSet<&turborepo_lockfiles::Package>,
  root_path: &AbsoluteSystemPath,
- root_package_json: &PackageJson,
+ root_workspace: &WorkspaceInfo,
  package_manager: &PackageManager,
  lockfile: Option<&L>,
  global_file_dependencies: &'a [String],
@@ -107,8 +107,7 @@ pub fn get_global_hash_inputs<'a, L: ?Sized + Lockfile>(
  }
  }
 
- let root_external_dependencies_hash =
- root_package_json.get_external_deps_hash(root_external_dependencies);
+ let root_external_dependencies_hash = root_workspace.get_external_deps_hash();
 
  debug!(
  "rust external deps hash: {}",

crates/turborepo-lib/src/run/mod.rs

@@ -115,9 +115,6 @@ impl Run {
  // }
  let env_at_execution_start = EnvironmentVariableMap::infer();
 
- let root_external_dependencies =
- pkg_dep_graph.transitive_external_dependencies(std::iter::once(&WorkspaceName::Root));
-
  let team_id = self.base.repo_config()?.team_id();
 
  let token = self.base.user_config()?.token();
@@ -181,10 +178,13 @@ impl Run {
  return Ok(());
  }
 
+ let root_workspace = pkg_dep_graph
+ .workspace_info(&WorkspaceName::Root)
+ .expect("must have root workspace");
+
  let global_hash_inputs = get_global_hash_inputs(
- root_external_dependencies,
  &self.base.repo_root,
- pkg_dep_graph.root_package_json(),
+ root_workspace,
  pkg_dep_graph.package_manager(),
  pkg_dep_graph.lockfile(),
  &root_turbo_json.global_deps,
@@ -245,18 +245,18 @@ impl Run {
  let root_turbo_json =
  TurboJson::load(&self.base.repo_root, &root_package_json, is_single_package)?;
 
- let root_external_dependencies =
- pkg_dep_graph.transitive_external_dependencies(std::iter::once(&WorkspaceName::Root));
-
  let scm = SCM::new(&self.base.repo_root);
 
  let filtered_pkgs =
  scope::resolve_packages(&opts.scope_opts, &self.base, &pkg_dep_graph, &scm)?;
 
+ let root_workspace = pkg_dep_graph
+ .workspace_info(&WorkspaceName::Root)
+ .expect("must have root workspace");
+
  let global_hash_inputs = get_global_hash_inputs(
- root_external_dependencies,
  &self.base.repo_root,
- pkg_dep_graph.root_package_json(),
+ root_workspace,
  pkg_dep_graph.package_manager(),
  pkg_dep_graph.lockfile(),
  &root_turbo_json.global_deps,

crates/turborepo-lib/src/run/task_id.rs

@@ -10,8 +10,8 @@ pub const ROOT_PKG_NAME: &str = "//";
 /// A task identifier as it will appear in the task graph
 #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize)]
 pub struct TaskId<'a> {
- package: Cow<'a, str>,
- task: Cow<'a, str>,
+ pub(crate) package: Cow<'a, str>,
+ pub(crate) task: Cow<'a, str>,
 }
 
 /// A task name as it appears in in a `turbo.json` it might be for all

crates/turborepo-lib/src/task_graph/mod.rs

@@ -74,9 +74,9 @@ pub struct TaskDefinition {
  pub(crate) cache: bool,
 
  // This field is custom-marshalled from `env` and `depends_on``
- env: Vec<String>,
+ pub(crate) env: Vec<String>,
 
- pass_through_env: Vec<String>,
+ pub(crate) pass_through_env: Vec<String>,
 
  pub(crate) dot_env: Vec<RelativeUnixPathBuf>,