chore: minor clean up and derive more behavior on events (#381)

* feat: derive event header traits

IPLD impls debug, PartialEq, Eq so unless we allow true floats I think this is okay

* chore: clean up errors and unused code

event/src/bytes.rs

@@ -6,7 +6,7 @@ use serde::{
 };
 
 /// Sequence of byte values.
-#[derive(Clone, PartialEq, Default, Debug)]
+#[derive(Clone, PartialEq, Eq, Default, Debug)]
 pub struct Bytes(Vec<u8>);
 
 impl Bytes {

event/src/unvalidated/payload/init.rs

@@ -26,7 +26,7 @@ impl<D> Payload<D> {
 }
 
 /// Headers for an init event
-#[derive(Default, Serialize, Deserialize)]
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Header {
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
@@ -81,4 +81,14 @@ impl Header {
     pub fn should_index(&self) -> bool {
         self.should_index.unwrap_or(true)
     }
+
+    /// The unique value for the stream
+    pub fn unique(&self) -> Option<&[u8]> {
+        self.unique.as_ref().map(Bytes::as_slice)
+    }
+
+    /// The context value for the stream
+    pub fn context(&self) -> Option<&[u8]> {
+        self.context.as_ref().map(Bytes::as_slice)
+    }
 }

service/src/error.rs

@@ -81,34 +81,21 @@ impl Error {
 impl From<Error> for recon::Error {
     fn from(value: Error) -> Self {
         match value {
-            Error::Application { error } => recon::Error::Application {
-                error: error.context("recon error"),
-            },
-            Error::Fatal { error } => recon::Error::Fatal {
-                error: error.context("recon error"),
-            },
-            Error::Transient { error } => recon::Error::Transient {
-                error: error.context("recon error"),
-            },
-            Error::InvalidArgument { error } => recon::Error::Application {
-                error: error.context("recon error"),
-            },
+            Error::Application { error } => recon::Error::Application { error },
+            Error::Fatal { error } => recon::Error::Fatal { error },
+            Error::Transient { error } => recon::Error::Transient { error },
+            Error::InvalidArgument { error } => recon::Error::Application { error },
         }
     }
 }
 
 impl From<ceramic_store::Error> for Error {
     fn from(value: ceramic_store::Error) -> Self {
         match value {
-            ceramic_store::Error::Application { error } => Error::Application {
-                error: error.context("store error"),
-            },
-            ceramic_store::Error::Fatal { error } => Error::Fatal {
-                error: error.context("store error"),
-            },
-            ceramic_store::Error::Transient { error } => Error::Transient {
-                error: error.context("store error"),
-            },
+            ceramic_store::Error::Application { error } => Error::Application { error },
+            ceramic_store::Error::Fatal { error } => Error::Fatal { error },
+            ceramic_store::Error::Transient { error } => Error::Transient { error },
+            ceramic_store::Error::InvalidArgument { error } => Error::InvalidArgument { error },
         }
     }
 }

store/src/error.rs

@@ -9,6 +9,12 @@ pub enum Error {
         /// The error details that may include context and other information
         error: anyhow::Error,
     },
+    #[error("InvalidArgument: {error}")]
+    /// Invalid client input
+    InvalidArgument {
+        /// The error details that may include context and other information
+        error: anyhow::Error,
+    },
     #[error("Fatal error encountered: {error}")]
     /// A fatal error that is unlikely to be recoverable, and may require terminating the process completely
     Fatal {
@@ -45,6 +51,13 @@ impl Error {
         }
     }
 
+    /// Crate an InvalidArgument error
+    pub fn new_invalid_arg(error: impl Into<anyhow::Error>) -> Self {
+        Self::InvalidArgument {
+            error: error.into(),
+        }
+    }
+
     /// Add context to the internal error. Works identically to `anyhow::context`
     pub fn context<C>(self, context: C) -> Self
     where
@@ -60,6 +73,9 @@ impl Error {
             Error::Transient { error } => Self::Transient {
                 error: error.context(context),
             },
+            Error::InvalidArgument { error } => Self::InvalidArgument {
+                error: error.context(context),
+            },
         }
     }
 }
@@ -115,6 +131,7 @@ impl From<Error> for recon::Error {
             Error::Application { error } => recon::Error::Application { error },
             Error::Fatal { error } => recon::Error::Fatal { error },
             Error::Transient { error } => recon::Error::Transient { error },
+            Error::InvalidArgument { error } => recon::Error::Application { error },
         }
     }
 }