update wit

Author: dr-frmr

kinode-wit

@@ -1,4 +1,4 @@
-pub use crate::{Address, PackageId, ProcessId};
+pub use crate::{Address, ProcessId};
 use serde::{Deserialize, Serialize};
 use std::hash::{Hash, Hasher};
 
@@ -39,8 +39,8 @@ impl Address {
         &self.process.publisher_node
     }
     /// Read the package_id (package + publisher) from an `Address`.
-    pub fn package_id(&self) -> PackageId {
-        PackageId::new(self.package(), self.publisher())
+    pub fn package_id(&self) -> crate::PackageId {
+        crate::PackageId::new(self.package(), self.publisher())
     }
 }
 

src/types/address.rs

@@ -1,15 +1,9 @@
+pub use crate::PackageId;
 use crate::ProcessIdParseError;
 use serde::{Deserialize, Serialize};
-use std::hash::Hash;
-
-/// PackageId is like a ProcessId, but for a package. Only contains the name
-/// of the package and the name of the publisher.
-#[derive(Hash, Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
-pub struct PackageId {
-    package_name: String,
-    publisher_node: String,
-}
 
+/// `PackageId` is defined in the wit bindings, but constructors and methods
+/// are defined here. A `PackageId` contains a package name and a publisher node ID.
 impl PackageId {
     /// Create a new `PackageId`.
     pub fn new(package_name: &str, publisher_node: &str) -> Self {
@@ -31,6 +25,32 @@ impl PackageId {
     }
 }
 
+impl Serialize for PackageId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::ser::Serializer,
+    {
+        format!("{}", self).serialize(serializer)
+    }
+}
+
+impl<'a> Deserialize<'a> for PackageId {
+    fn deserialize<D>(deserializer: D) -> Result<PackageId, D::Error>
+    where
+        D: serde::de::Deserializer<'a>,
+    {
+        let s = String::deserialize(deserializer)?;
+        s.parse().map_err(serde::de::Error::custom)
+    }
+}
+
+impl std::hash::Hash for PackageId {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.package_name.hash(state);
+        self.publisher_node.hash(state);
+    }
+}
+
 impl std::str::FromStr for PackageId {
     type Err = ProcessIdParseError;
     /// Attempt to parse a `PackageId` from a string. The string must
@@ -69,3 +89,9 @@ impl std::fmt::Display for PackageId {
         write!(f, "{}:{}", self.package_name, self.publisher_node)
     }
 }
+
+impl PartialEq for PackageId {
+    fn eq(&self, other: &Self) -> bool {
+        self.package_name == other.package_name && self.publisher_node == other.publisher_node
+    }
+}