feat: construct package entry

Author: kayagokalp

src/handlers/publish.rs

@@ -1,6 +1,7 @@
 use crate::api::publish::PublishRequest;
 use crate::db::error::DatabaseError;
 use crate::db::Database;
+use crate::index::{PackageDependencyIdentifier, PackageEntry};
 use crate::models::{ApiToken, NewPackageDep};
 use forc_pkg::PackageManifest;
 use semver::Version;
@@ -34,7 +35,7 @@ pub struct PublishInfo {
     pub license: Option<String>,
 }
 
-struct PartialPackageDep {
+pub struct PartialPackageDep {
     pub dependency_package_name: String,
     pub dependency_version_req: String,
 }
@@ -121,6 +122,22 @@ pub async fn handle_publish(
     );
 
     // TODO [https://github.com/FuelLabs/forc.pub/issues/28]: Publish to GitHub index repo.
+    let package_name = publish_info.package_name.clone();
+    let package_version = publish_info.num.clone();
+    let source_cid = upload.source_code_ipfs_hash;
+    let abi_cid = upload.abi_ipfs_hash;
+    let dependencies = package_deps
+        .into_iter()
+        .map(|package_dep| PackageDependencyIdentifier::from(package_dep))
+        .collect();
+
+    let package_entry = PackageEntry::new(
+        package_name,
+        package_version,
+        source_cid,
+        abi_cid,
+        dependencies,
+    );
 
     Ok(publish_info)
 }

src/index.rs

@@ -14,12 +14,14 @@
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
+use crate::handlers::publish::PartialPackageDep;
+
 #[derive(Serialize, Deserialize)]
 pub struct IndexFile {
     /// Each published instance for this specific package, keyed by their
     /// versions. The reason we are doing this type of mapping is for use of
-    /// ease, we are effectively duplicating version of package but keeping
-    /// `PackageEntry` self contained.
+    /// ease and deterministic ordering, we are effectively duplicating version
+    /// of package but keeping `PackageEntry` self contained.
     #[serde(flatten)]
     versions: BTreeMap<semver::Version, PackageEntry>,
 }
@@ -35,7 +37,7 @@ pub struct IndexFile {
 /// 5. Dependencies of this package. If there are other packages this package
 ///    depends on, some information can be directly found in the root package
 ///    to enable parallel fetching.
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct PackageEntry {
     /// Name of the package.
     /// This is the actual package name needed in forc.toml file to fetch this
@@ -56,7 +58,46 @@ pub struct PackageEntry {
     abi_cid: Option<String>,
     /// Dependencies of the current package entry. Can be consumed to enable
     /// parallel fetching by the consumers of this index, mainly forc.
-    dependencies: Vec<Box<PackageEntry>>,
+    dependencies: Vec<PackageDependencyIdentifier>,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct PackageDependencyIdentifier {
+    /// Name of the dependency.
+    /// Name and version information can be used by consumer of this index
+    /// to resolve dependencies.
+    package_name: String,
+    /// Version of the dependency.
+    /// Name and version information can be used by consumer of this index
+    /// to resolve dependencies.
+    version: String,
+}
+
+impl PackageEntry {
+    pub fn new(
+        package_name: String,
+        version: semver::Version,
+        source_cid: String,
+        abi_cid: Option<String>,
+        dependencies: Vec<PackageDependencyIdentifier>,
+    ) -> Self {
+        Self {
+            package_name,
+            version,
+            source_cid,
+            abi_cid,
+            dependencies,
+        }
+    }
+}
+
+impl From<PartialPackageDep> for PackageDependencyIdentifier {
+    fn from(value: PartialPackageDep) -> Self {
+        Self {
+            package_name: value.dependency_package_name,
+            version: value.dependency_version_req,
+        }
+    }
 }
 
 #[cfg(test)]
@@ -108,47 +149,39 @@ mod tests {
         let v011 = &deserialized.versions[&semver::Version::new(0, 11, 0)];
         assert_eq!(v011.source_cid, "QmOlderHash");
         assert_eq!(v011.abi_cid, Some("QmOlderAbiHash".to_string()));
+        assert_eq!(v011.dependencies.len(), 0);
 
         let v012 = &deserialized.versions[&semver::Version::new(0, 12, 0)];
         assert_eq!(v012.source_cid, "QmExampleHash");
         assert_eq!(v012.abi_cid, Some("QmExampleAbiHash".to_string()));
+        assert_eq!(v012.dependencies.len(), 0);
     }
 
     #[test]
     fn test_json_with_dependencies() {
-        // Test parsing a JSON with nested dependencies
+        // Test parsing a JSON with dependencies
         let json = r#"{
-        "1.0.0": {
-            "package_name": "main-package",
-            "version": "1.0.0",
-            "source_cid": "QmMainHash",
-            "abi_cid": null,
-            "dependencies": [
-                {
-                    "package_name": "dep-package",
-                    "version": "0.5.0",
-                    "source_cid": "QmDepHash",
-                    "abi_cid": "QmDepAbiHash",
-                    "dependencies": []
-                },
-                {
-                    "package_name": "another-dep",
-                    "version": "0.9.1",
-                    "source_cid": "QmAnotherDepHash",
-                    "abi_cid": null,
-                    "dependencies": [
-                        {
-                            "package_name": "nested-dep",
-                            "version": "0.2.0",
-                            "source_cid": "QmNestedHash",
-                            "abi_cid": "QmNestedAbiHash",
-                            "dependencies": []
-                        }
-                    ]
-                }
-            ]
-        }
-    }"#;
+            "1.0.0": {
+                "package_name": "main-package",
+                "version": "1.0.0",
+                "source_cid": "QmMainHash",
+                "abi_cid": null,
+                "dependencies": [
+                    {
+                        "package_name": "dep-package",
+                        "version": "^0.5.0"
+                    },
+                    {
+                        "package_name": "another-dep",
+                        "version": "=0.9.1"
+                    },
+                    {
+                        "package_name": "third-dep",
+                        "version": "0.2.0"
+                    }
+                ]
+            }
+        }"#;
 
         let deserialized: IndexFile = serde_json::from_str(json).unwrap();
 
@@ -163,44 +196,35 @@ mod tests {
         assert_eq!(main_pkg.source_cid, "QmMainHash");
         assert_eq!(main_pkg.abi_cid, None);
 
-        // Verify first-level dependencies
-        assert_eq!(main_pkg.dependencies.len(), 2);
+        // Verify dependencies
+        assert_eq!(main_pkg.dependencies.len(), 3);
 
         // Check first dependency
         let dep1 = &main_pkg.dependencies[0];
         assert_eq!(dep1.package_name, "dep-package");
-        assert_eq!(dep1.version, semver::Version::new(0, 5, 0));
-        assert_eq!(dep1.source_cid, "QmDepHash");
-        assert_eq!(dep1.abi_cid, Some("QmDepAbiHash".to_string()));
-        assert_eq!(dep1.dependencies.len(), 0);
+        assert_eq!(dep1.version, "^0.5.0");
 
         // Check second dependency
         let dep2 = &main_pkg.dependencies[1];
         assert_eq!(dep2.package_name, "another-dep");
-        assert_eq!(dep2.version, semver::Version::new(0, 9, 1));
-        assert_eq!(dep2.source_cid, "QmAnotherDepHash");
-        assert_eq!(dep2.abi_cid, None);
-
-        // Verify nested dependency
-        assert_eq!(dep2.dependencies.len(), 1);
-        let nested_dep = &dep2.dependencies[0];
-        assert_eq!(nested_dep.package_name, "nested-dep");
-        assert_eq!(nested_dep.version, semver::Version::new(0, 2, 0));
-        assert_eq!(nested_dep.source_cid, "QmNestedHash");
-        assert_eq!(nested_dep.abi_cid, Some("QmNestedAbiHash".to_string()));
-        assert_eq!(nested_dep.dependencies.len(), 0);
+        assert_eq!(dep2.version, "=0.9.1");
+
+        // Check third dependency
+        let dep3 = &main_pkg.dependencies[2];
+        assert_eq!(dep3.package_name, "third-dep");
+        assert_eq!(dep3.version, "0.2.0");
 
         // Test round-trip serialization
         let serialized = serde_json::to_string_pretty(&deserialized).unwrap();
+        println!("Re-serialized JSON: {}", serialized);
 
         // Deserialize again to ensure it's valid
         let re_deserialized: IndexFile = serde_json::from_str(&serialized).unwrap();
         assert_eq!(re_deserialized.versions.len(), 1);
 
         // Verify the structure is preserved
         let main_pkg2 = &re_deserialized.versions[&semver::Version::new(1, 0, 0)];
-        assert_eq!(main_pkg2.dependencies.len(), 2);
-        assert_eq!(main_pkg2.dependencies[1].dependencies.len(), 1);
+        assert_eq!(main_pkg2.dependencies.len(), 3);
     }
 
     #[test]
@@ -222,5 +246,31 @@ mod tests {
         assert_eq!(pkg.package_name, "minimal-package");
         assert_eq!(pkg.source_cid, "QmMinimalHash");
         assert_eq!(pkg.abi_cid, None);
+        assert_eq!(pkg.dependencies.len(), 0);
+    }
+
+    #[test]
+    fn test_package_entry_new() {
+        // Test the new() constructor method
+        let dependencies = vec![PackageDependencyIdentifier {
+            package_name: "dep1".to_string(),
+            version: "^1.0".to_string(),
+        }];
+
+        let entry = PackageEntry::new(
+            "test-package".to_string(),
+            semver::Version::new(2, 0, 0),
+            "QmTestHash".to_string(),
+            Some("QmAbiHash".to_string()),
+            dependencies.clone(),
+        );
+
+        assert_eq!(entry.package_name, "test-package");
+        assert_eq!(entry.version, semver::Version::new(2, 0, 0));
+        assert_eq!(entry.source_cid, "QmTestHash");
+        assert_eq!(entry.abi_cid, Some("QmAbiHash".to_string()));
+        assert_eq!(entry.dependencies.len(), 1);
+        assert_eq!(entry.dependencies[0].package_name, "dep1");
+        assert_eq!(entry.dependencies[0].version, "^1.0");
     }
 }