feat(bun): bun prune support (#10175)

### Description
Resolves #9058 and
#7456

Building on #9783 to add `prune`
support for bun. This is a simple implementation that allow turbo to
properly prune a `bun.lock` file

Basically, it just creates a new `BunLockfileData` with the filtered
dependencies/workspaces and serializes it to `bun.lock` via
`serde_json`. This is made simple since the internal layout matches the
bun.lock format, so the only special serialization case I had to do was
`PackageEntry`. This also required updating the _deserialization_, since
it skipped parsing some parts that we need to write back out.
 
### Testing Instructions
1. Clone https://github.com/mugencraft/turbobun (or any other turbo +
bun repo)
2. `bun install --save-text-lockfile` (we need the new `.lock` version
and not `.lockb`)
3. I then do 
    ```sh
rm -rf ./out && cp ../turborepo/target/debug/turbo
./node_modules/.bin/turbo # Copy debug build of turbo
bunx turbo prune @turbobun/backend --docker --skip-infer # turbo prune 🚀
    ```
4. Open the generated `out/bun.lock`. It's currently outputted in an
unformatted json, so I format it.
5. Observe that the dependencies include backend (`elysia`) and root
workspace (`commitizen`) dependencies, but not e.g. `@turbobun/website`
dependencies (like `next`)
6. `cd ./out/json && bun install` -> Bun install can read the lockfile
and works!
7. You can also patch a random package using `bun patch` and test that
the patches are propagated correctly

### Screenshots

![image](https://github.com/user-attachments/assets/8e059425-8e87-4d6e-9360-d49fbf65d105)

---------

Co-authored-by: Chris Olszewski <[email protected]>

Author: camero2734

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

@@ -47,8 +47,6 @@ pub enum Error {
     MissingWorkspace(PackageName),
     #[error("Cannot prune without parsed lockfile.")]
     MissingLockfile,
-    #[error("`prune` is not supported for Bun.")]
-    BunUnsupported,
     #[error("Unable to read config: {0}")]
     Config(#[from] crate::config::Error),
 }
@@ -106,13 +104,6 @@ pub async fn prune(
 
     let prune = Prune::new(base, scope, docker, output_dir, use_gitignore, telemetry).await?;
 
-    if matches!(
-        prune.package_graph.package_manager(),
-        turborepo_repository::package_manager::PackageManager::Bun
-    ) {
-        return Err(Error::BunUnsupported);
-    }
-
     println!(
         "Generating pruned monorepo for {} in {}",
         base.color_config.apply(BOLD.apply_to(scope.join(", "))),

crates/turborepo-lockfiles/src/bun/de.rs

@@ -3,6 +3,7 @@ use std::collections::VecDeque;
 use serde::Deserialize;
 
 use super::{PackageEntry, PackageInfo};
+use crate::bun::RootInfo;
 // Comment explaining entry schemas taken from bun.lock.zig
 // first index is resolution for each type of package
 // npm         -> [
@@ -32,6 +33,8 @@ impl<'de> Deserialize<'de> for PackageEntry {
             Info(Box<PackageInfo>),
         }
         let mut vals = VecDeque::<Vals>::deserialize(deserializer)?;
+
+        // First value is always the package key
         let key = vals
             .pop_front()
             .ok_or_else(|| de::Error::custom("expected package entry to not be empty"))?;
@@ -44,22 +47,53 @@ impl<'de> Deserialize<'de> for PackageEntry {
             Vals::Str(_) => None,
             Vals::Info(package_info) => Some(*package_info),
         };
-        // For workspace packages deps are second element, rest have them as third
-        // element
-        let info = vals
-            .pop_front()
-            .and_then(val_to_info)
-            .or_else(|| vals.pop_front().and_then(val_to_info));
+
+        let mut registry = None;
+        let mut info = None;
+
+        // Special case: root packages have a unique second value, so we handle it here
+        if key.ends_with("@root:") {
+            let root = vals.pop_front().and_then(|val| {
+                serde_json::from_value::<RootInfo>(match val {
+                    Vals::Info(info) => {
+                        serde_json::to_value(info.other).expect("failed to convert info to value")
+                    }
+                    _ => return None,
+                })
+                .ok()
+            });
+            return Ok(Self {
+                ident: key,
+                info,
+                registry,
+                checksum: None,
+                root,
+            });
+        }
+
+        // The second value can be either registry (string) or info (object)
+        if let Some(val) = vals.pop_front() {
+            match val {
+                Vals::Str(reg) => registry = Some(reg),
+                Vals::Info(package_info) => info = Some(*package_info),
+            }
+        };
+
+        // Info will be next if we haven't already found it
+        if info.is_none() {
+            info = vals.pop_front().and_then(val_to_info);
+        }
+
+        // Checksum is last
         let checksum = vals.pop_front().and_then(|val| match val {
             Vals::Str(sha) => Some(sha),
             Vals::Info(_) => None,
         });
+
         Ok(Self {
             ident: key,
             info,
-            // The rest are only necessary for serializing a lockfile and aren't needed until adding
-            // `prune` support
-            registry: None,
+            registry,
             checksum,
             root: None,
         })
@@ -114,7 +148,7 @@ mod test {
         PackageEntry,
         PackageEntry {
             ident: "[email protected]".into(),
-            registry: None,
+            registry: Some("".into()),
             info: Some(PackageInfo {
                 dependencies: Some(("is-number".into(), "^6.0.0".into()))
                     .into_iter()
@@ -142,10 +176,26 @@ mod test {
             root: None,
         }
     );
+
+    fixture!(
+        root_pkg,
+        PackageEntry,
+        PackageEntry {
+            ident: "some-package@root:".into(),
+            root: Some(RootInfo {
+                bin: Some("bin".into()),
+                bin_dir: Some("binDir".into()),
+            }),
+            info: None,
+            registry: None,
+            checksum: None,
+        }
+    );
     #[test_case(json!({"name": "bun-test", "devDependencies": {"turbo": "^2.3.3"}}), basic_workspace() ; "basic")]
     #[test_case(json!({"name": "docs", "version": "0.1.0"}), workspace_with_version() ; "with version")]
     #[test_case(json!(["[email protected]", "", {"dependencies": {"is-number": "^6.0.0"}}, "sha"]), registry_pkg() ; "registry package")]
     #[test_case(json!(["docs", {"dependencies": {"is-odd": "3.0.1"}}]), workspace_pkg() ; "workspace package")]
+    #[test_case(json!(["some-package@root:", {"bin": "bin", "binDir": "binDir"}]), root_pkg() ; "root package")]
     fn test_deserialization<T: for<'a> Deserialize<'a> + PartialEq + std::fmt::Debug>(
         input: serde_json::Value,
         expected: &T,