chore(turbo_json): prefactor loading logic (#10719)

### Description

This PR is a prefactor to make the process of constructing a task
definition clearer:
- move `TaskId`/`TaskName` out of `turborepo-lib` so they can be
available if `turbo.json` ever moves to a new crate
 - move configuration logic to configuration crate
 - documenting how `turbo.json`s on disk become task definitions.

Highly suggest looking at each commit on it's own.

### Testing Instructions

👀

Author: chris-olszewski

Cargo.lock

@@ -65,6 +65,7 @@ turborepo-lockfiles = { path = "crates/turborepo-lockfiles" }
 turborepo-microfrontends = { path = "crates/turborepo-microfrontends" }
 turborepo-process = { path = "crates/turborepo-process" }
 turborepo-repository = { path = "crates/turborepo-repository" }
+turborepo-task-id = { path = "crates/turborepo-task-id" }
 turborepo-ui = { path = "crates/turborepo-ui" }
 turborepo-unescape = { path = "crates/turborepo-unescape" }
 turborepo-scm = { path = "crates/turborepo-scm" }

Cargo.toml

@@ -141,6 +141,7 @@ turborepo-process = { workspace = true }
 turborepo-repository = { path = "../turborepo-repository" }
 turborepo-scm = { workspace = true, features = ["git2"] }
 turborepo-signals = { workspace = true }
+turborepo-task-id = { workspace = true }
 turborepo-telemetry = { path = "../turborepo-telemetry" }
 turborepo-ui = { workspace = true }
 turborepo-unescape = { workspace = true }

crates/turborepo-lib/Cargo.toml

@@ -8,9 +8,11 @@ use turborepo_ui::ColorConfig;
 
 use crate::{
     cli,
-    config::{ConfigurationOptions, Error as ConfigError, TurborepoConfigBuilder},
+    config::{
+        resolve_turbo_config_path, ConfigurationOptions, Error as ConfigError,
+        TurborepoConfigBuilder,
+    },
     opts::Opts,
-    turbo_json::resolve_turbo_config_path,
     Args,
 };
 

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

@@ -16,7 +16,10 @@ use turborepo_telemetry::events::command::CommandEventBuilder;
 use turborepo_ui::BOLD;
 
 use super::CommandBase;
-use crate::turbo_json::{RawTurboJson, CONFIG_FILE, CONFIG_FILE_JSONC};
+use crate::{
+    config::{CONFIG_FILE, CONFIG_FILE_JSONC},
+    turbo_json::RawTurboJson,
+};
 
 pub const DEFAULT_OUTPUT_DIR: &str = "out";
 

crates/turborepo-lib/src/commands/prune.rs

@@ -23,11 +23,11 @@ use turborepo_cache::CacheConfig;
 use turborepo_errors::TURBO_SITE;
 use turborepo_repository::package_graph::PackageName;
 
+use crate::cli::{EnvMode, LogOrder};
 pub use crate::turbo_json::{RawTurboJson, UIMode};
-use crate::{
-    cli::{EnvMode, LogOrder},
-    turbo_json::resolve_turbo_config_path,
-};
+
+pub const CONFIG_FILE: &str = "turbo.json";
+pub const CONFIG_FILE_JSONC: &str = "turbo.jsonc";
 
 #[derive(Debug, Error, Diagnostic)]
 #[error("Environment variables should not be prefixed with \"{env_pipeline_delimiter}\"")]
@@ -566,19 +566,42 @@ impl TurborepoConfigBuilder {
     }
 }
 
+/// Given a directory path, determines which turbo.json configuration file to
+/// use. Returns an error if both turbo.json and turbo.jsonc exist in the same
+/// directory. Returns the path to the config file to use, defaulting to
+/// turbo.json if neither exists.
+pub fn resolve_turbo_config_path(
+    dir_path: &turbopath::AbsoluteSystemPath,
+) -> Result<turbopath::AbsoluteSystemPathBuf, crate::config::Error> {
+    use crate::config::Error;
+
+    let turbo_json_path = dir_path.join_component(CONFIG_FILE);
+    let turbo_jsonc_path = dir_path.join_component(CONFIG_FILE_JSONC);
+
+    let turbo_json_exists = turbo_json_path.try_exists()?;
+    let turbo_jsonc_exists = turbo_jsonc_path.try_exists()?;
+
+    match (turbo_json_exists, turbo_jsonc_exists) {
+        (true, true) => Err(Error::MultipleTurboConfigs {
+            directory: dir_path.to_string(),
+        }),
+        (true, false) => Ok(turbo_json_path),
+        (false, true) => Ok(turbo_jsonc_path),
+        // Default to turbo.json if neither exists
+        (false, false) => Ok(turbo_json_path),
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::{collections::HashMap, ffi::OsString};
 
     use tempfile::TempDir;
     use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf};
 
-    use crate::{
-        config::{
-            ConfigurationOptions, TurborepoConfigBuilder, DEFAULT_API_URL, DEFAULT_LOGIN_URL,
-            DEFAULT_TIMEOUT,
-        },
-        turbo_json::{CONFIG_FILE, CONFIG_FILE_JSONC},
+    use crate::config::{
+        ConfigurationOptions, TurborepoConfigBuilder, CONFIG_FILE, CONFIG_FILE_JSONC,
+        DEFAULT_API_URL, DEFAULT_LOGIN_URL, DEFAULT_TIMEOUT,
     };
 
     #[test]

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

@@ -2,12 +2,44 @@ use camino::Utf8PathBuf;
 use turbopath::{AbsoluteSystemPath, RelativeUnixPath};
 
 use super::{ConfigurationOptions, Error, ResolvedConfigurationOptions};
-use crate::turbo_json::RawTurboJson;
+use crate::turbo_json::{RawRemoteCacheOptions, RawTurboJson};
 
 pub struct TurboJsonReader<'a> {
     repo_root: &'a AbsoluteSystemPath,
 }
 
+impl From<&RawRemoteCacheOptions> for ConfigurationOptions {
+    fn from(remote_cache_opts: &RawRemoteCacheOptions) -> Self {
+        Self {
+            api_url: remote_cache_opts
+                .api_url
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            login_url: remote_cache_opts
+                .login_url
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            team_slug: remote_cache_opts
+                .team_slug
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            team_id: remote_cache_opts
+                .team_id
+                .as_ref()
+                .map(|s| s.as_inner().clone()),
+            signature: remote_cache_opts.signature.as_ref().map(|s| *s.as_inner()),
+            preflight: remote_cache_opts.preflight.as_ref().map(|s| *s.as_inner()),
+            timeout: remote_cache_opts.timeout.as_ref().map(|s| *s.as_inner()),
+            upload_timeout: remote_cache_opts
+                .upload_timeout
+                .as_ref()
+                .map(|s| *s.as_inner()),
+            enabled: remote_cache_opts.enabled.as_ref().map(|s| *s.as_inner()),
+            ..Self::default()
+        }
+    }
+}
+
 impl<'a> TurboJsonReader<'a> {
     pub fn new(repo_root: &'a AbsoluteSystemPath) -> Self {
         Self { repo_root }
@@ -68,7 +100,7 @@ mod test {
     use tempfile::tempdir;
 
     use super::*;
-    use crate::turbo_json::CONFIG_FILE;
+    use crate::config::CONFIG_FILE;
 
     #[test]
     fn test_reads_from_default() {

crates/turborepo-lib/src/config/turbo_json.rs

@@ -7,11 +7,11 @@ use turbopath::{AbsoluteSystemPath, AnchoredSystemPathBuf, RelativeUnixPathBuf};
 use turborepo_errors::{Spanned, TURBO_SITE};
 use turborepo_graph_utils as graph;
 use turborepo_repository::package_graph::{PackageGraph, PackageName, PackageNode, ROOT_PKG_NAME};
+use turborepo_task_id::{TaskId, TaskName};
 
 use super::Engine;
 use crate::{
     config,
-    run::task_id::{TaskId, TaskName},
     task_graph::TaskDefinition,
     turbo_json::{
         validate_extends, validate_no_package_task_syntax, validate_with_has_no_topo,

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

@@ -4,9 +4,9 @@ use futures::{stream::FuturesUnordered, StreamExt};
 use tokio::sync::{mpsc, oneshot, Semaphore};
 use tracing::log::debug;
 use turborepo_graph_utils::Walker;
+use turborepo_task_id::TaskId;
 
 use super::{Engine, TaskNode};
-use crate::run::task_id::TaskId;
 
 pub struct Message<T, U> {
     pub info: T,

crates/turborepo-lib/src/engine/execute.rs

@@ -16,8 +16,9 @@ use petgraph::Graph;
 use thiserror::Error;
 use turborepo_errors::Spanned;
 use turborepo_repository::package_graph::{PackageGraph, PackageName};
+use turborepo_task_id::TaskId;
 
-use crate::{run::task_id::TaskId, task_graph::TaskDefinition, turbo_json::UIMode};
+use crate::{task_graph::TaskDefinition, turbo_json::UIMode};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum TaskNode {
@@ -612,9 +613,9 @@ mod test {
         discovery::{DiscoveryResponse, PackageDiscovery, WorkspaceData},
         package_json::PackageJson,
     };
+    use turborepo_task_id::TaskName;
 
     use super::*;
-    use crate::run::task_id::TaskName;
 
     struct DummyDiscovery<'a>(&'a TempDir);