Properly deserialize and serialize

Author: camero2734

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         -> [
@@ -25,7 +26,7 @@ impl<'de> Deserialize<'de> for PackageEntry {
         D: serde::Deserializer<'de>,
     {
         use serde::de;
-        #[derive(Deserialize)]
+        #[derive(Deserialize, Debug)]
         #[serde(untagged)]
         enum Vals {
             Str(String),
@@ -46,20 +47,50 @@ impl<'de> Deserialize<'de> for PackageEntry {
         };
         // 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;
+
+        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)
+        vals.pop_front().map(|val| 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 +145,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 +173,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,

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

@@ -2,81 +2,156 @@ use serde::{ser::SerializeTuple, Serialize};
 
 use super::PackageEntry;
 
+// Comment explaining entry schemas taken from bun.lock.zig
+// first index is resolution for each type of package
+// npm         -> [
+//                "name@version",
+//                registry (TODO: remove if default),
+//                INFO,
+//                integrity
+//                ]
+// symlink     -> [ "name@link:path", INFO ]
+// folder      -> [ "name@file:path", INFO ]
+// workspace   -> [ "name@workspace:path", INFO ]
+// tarball     -> [ "name@tarball", INFO ]
+// root        -> [ "name@root:", { bin, binDir } ]
+// git         -> [ "name@git+repo", INFO, .bun-tag string (TODO: remove this) ]
+// github      -> [ "name@github:user/repo", INFO, .bun-tag string (TODO: remove
+// this) ]
 impl Serialize for PackageEntry {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut tuple = serializer.serialize_tuple(5)?;
+        let mut tuple = serializer.serialize_tuple(4)?;
         tuple.serialize_element(&self.ident)?;
 
+        // For root packages, only thing left to serialize is the root info
+        if let Some(root) = &self.root {
+            tuple.serialize_element(root)?;
+            return tuple.end();
+        }
+
+        // npm packages have a registry
+        if let Some(registry) = &self.registry {
+            tuple.serialize_element(registry)?;
+        }
+
+        // All packages have info in the next slot
         if let Some(info) = &self.info {
-            tuple.serialize_element(&self.registry.as_deref().unwrap_or(""))?;
             tuple.serialize_element(info)?;
-            tuple.serialize_element(&self.checksum)?;
-            if let Some(root) = &self.root {
-                tuple.serialize_element(root)?;
-            }
         };
 
+        // npm packages, git, and github have a checksum/integrity
+        if let Some(checksum) = &self.checksum {
+            tuple.serialize_element(checksum)?;
+        }
+
         tuple.end()
     }
 }
 
 #[cfg(test)]
 mod test {
+    use std::{str::FromStr, sync::OnceLock};
+
     use serde_json::json;
+    use test_case::test_case;
 
     use super::*;
-    use crate::bun::PackageInfo;
+    use crate::{
+        bun::{PackageInfo, RootInfo, WorkspaceEntry},
+        BunLockfile,
+    };
+
+    macro_rules! fixture {
+        ($name:ident, $kind:ty, $cons:expr) => {
+            fn $name() -> &'static $kind {
+                static ONCE: OnceLock<$kind> = OnceLock::new();
+                ONCE.get_or_init(|| $cons)
+            }
+        };
+    }
+
+    fixture!(
+        basic_workspace,
+        WorkspaceEntry,
+        WorkspaceEntry {
+            name: "bun-test".into(),
+            dev_dependencies: Some(
+                Some(("turbo".to_string(), "^2.3.3".to_string()))
+                    .into_iter()
+                    .collect()
+            ),
+            ..Default::default()
+        }
+    );
+
+    fixture!(
+        workspace_with_version,
+        WorkspaceEntry,
+        WorkspaceEntry {
+            name: "docs".into(),
+            version: Some("0.1.0".into()),
+            ..Default::default()
+        }
+    );
 
-    #[test]
-    fn test_serialize_registry_package() {
-        let package = PackageEntry {
+    fixture!(
+        registry_pkg,
+        PackageEntry,
+        PackageEntry {
             ident: "[email protected]".into(),
-            registry: Some("registry".into()),
+            registry: Some("".into()),
             info: Some(PackageInfo {
-                dependencies: [("is-number".into(), "^6.0.0".into())]
+                dependencies: Some(("is-number".into(), "^6.0.0".into()))
                     .into_iter()
                     .collect(),
                 ..Default::default()
             }),
             checksum: Some("sha".into()),
             root: None,
-        };
-
-        let expected =
-            json!(["[email protected]", "registry", {"dependencies": {"is-number": "^6.0.0"}}, "sha"]);
-        let actual = serde_json::to_value(&package).unwrap();
-        assert_eq!(actual, expected);
-    }
+        }
+    );
 
-    #[test]
-    fn test_serialize_registry_package_no_deps() {
-        let package = PackageEntry {
-            ident: "[email protected]".into(),
-            registry: Some("registry".into()),
+    fixture!(
+        workspace_pkg,
+        PackageEntry,
+        PackageEntry {
+            ident: "docs".into(),
             info: Some(PackageInfo {
+                dependencies: Some(("is-odd".into(), "3.0.1".into()))
+                    .into_iter()
+                    .collect(),
                 ..Default::default()
             }),
-            checksum: Some("sha".into()),
-            root: None,
-        };
-
-        let expected = json!(["[email protected]", "registry", {}, "sha"]);
-        let actual = serde_json::to_value(&package).unwrap();
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_serialize_workspace_package() {
-        let package = PackageEntry {
-            ident: "@workspace/package".into(),
             registry: None,
-            info: None,
             checksum: None,
             root: None,
-        };
+        }
+    );
 
-        let expected = json!(["@workspace/package"]);
-        let actual = serde_json::to_value(&package).unwrap();
+    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_serialization<T: for<'a> Serialize + PartialEq + std::fmt::Debug>(
+        expected: serde_json::Value,
+        input: &T,
+    ) {
+        let actual = serde_json::to_value(input).unwrap();
         assert_eq!(actual, expected);
     }
 }