Chainmail: implement save/unsave message #855

services/user/Chainmail/plugin/Cargo.toml

@@ -13,6 +13,7 @@ psibase = { path = "../../../../rust/psibase/" }
 chainmail = { path = "../service" }
 serde_json = "1.0.128"
 serde = "1.0.210"
+serde-aux = "4.5.0"
 
 [dev-dependencies]
 chainmail_package = { path = "..", version = "0.13.0" }

services/user/Chainmail/plugin/src/errors.rs

@@ -3,11 +3,12 @@ use crate::bindings::host::common::types::{Error, PluginId};
 #[derive(PartialEq, Eq, Hash)]
 pub enum ErrorType {
     QueryResponseParseError,
+    InvalidMsgId,
 }
 
 fn my_plugin_id() -> PluginId {
     return PluginId {
-        service: "identity".to_string(),
+        service: "chainmail".to_string(),
         plugin: "plugin".to_string(),
     };
 }
@@ -20,6 +21,11 @@ impl ErrorType {
                 producer: my_plugin_id(),
                 message: format!("Query response parsing error: {}", msg),
             },
+            ErrorType::InvalidMsgId => Error {
+                code: self as u32,
+                producer: my_plugin_id(),
+                message: format!("No message found with msg_id {}", msg),
+            },
         }
     }
 }

services/user/Chainmail/plugin/src/lib.rs

@@ -1,28 +1,27 @@
+//! Chainmail Plugin: Basic Chainmail API
+//!
+//! Provides a convenient API for interacting with Chainmail, a simple email-like client.
+
 #[allow(warnings)]
 mod bindings;
 mod errors;
+mod queries;
+mod serde_structs;
 
-use bindings::exports::chainmail::plugin::api::{Error, Guest as Api};
-use bindings::exports::chainmail::plugin::queries::{Guest as Query, Message};
-use bindings::host::common::server as CommonServer;
+use bindings::exports::chainmail::plugin::{
+    api::{Error, Guest as Api},
+    queries::{Guest as Query, Message},
+};
 use bindings::transact::plugin::intf as Transact;
-use errors::ErrorType::QueryResponseParseError;
 use psibase::fracpack::Pack;
 use psibase::AccountNumber;
-use serde::Deserialize;
+use queries::{get_msg_by_id, query_messages_endpoint};
 
+/// Struct that implements the Api as well as the Query interfaces
 struct ChainmailPlugin;
 
-#[derive(Debug, Deserialize)]
-struct MessageSerde {
-    msg_id: String,
-    receiver: String,
-    sender: String,
-    subject: String,
-    body: String,
-}
-
 impl Api for ChainmailPlugin {
+    /// Send a message
     fn send(receiver: String, subject: String, body: String) -> Result<(), Error> {
         Transact::add_action_to_transaction(
             "send",
@@ -36,66 +35,71 @@ impl Api for ChainmailPlugin {
         Ok(())
     }
 
+    /// Archive a message
+    /// - msg_id: the message's rowid (from the events table)
+    ///
+    /// Archiving is equivalent to deleting, given message can't be truly deleted.
+    /// Archiving is a proactive action equivalent to a node pruning an message (an message's historical event)
     fn archive(msg_id: u64) -> Result<(), Error> {
         Transact::add_action_to_transaction(
             "archive",
             &chainmail::action_structs::archive { msg_id }.packed(),
         )?;
         Ok(())
     }
-}
 
-fn query_messages_endpoint(
-    sender: Option<String>,
-    receiver: Option<String>,
-    archived_requested: bool,
-) -> Result<Vec<Message>, Error> {
-    let mut endpoint = String::from("/api/messages?");
-    if archived_requested {
-        endpoint += "archived=true&";
-    }
-    if sender.is_some() {
-        endpoint += &format!("sender={}", sender.clone().unwrap());
-    }
-    if sender.is_some() && receiver.is_some() {
-        endpoint += "&";
-    }
-    if receiver.is_some() {
-        endpoint += &format!("receiver={}", receiver.unwrap());
-    }
+    /// Save the message
+    /// - msg_id: the message's rowid (from the events table)
+    ///
+    /// Saving a message moves it to state, making it long-lasting (immune to pruning)
+    fn save(msg_id: u64) -> Result<(), Error> {
+        let msg = get_msg_by_id(msg_id)?;
 
-    let resp = serde_json::from_str::<Vec<MessageSerde>>(&CommonServer::get_json(&endpoint)?);
-    let mut resp_val: Vec<MessageSerde>;
-    if resp.is_err() {
-        return Err(errors::ErrorType::QueryResponseParseError.err(&resp.unwrap_err().to_string()));
-    } else {
-        resp_val = resp.unwrap();
+        Transact::add_action_to_transaction(
+            "save",
+            &chainmail::action_structs::save {
+                subject: msg.subject.clone(),
+                body: msg.body.clone(),
+                receiver: AccountNumber::from(msg.receiver.as_str()),
+                msg_id: msg.msg_id,
+                sender: AccountNumber::from(msg.sender.as_str()),
+                datetime: msg.datetime,
+            }
+            .packed(),
+        )?;
+        Ok(())
     }
 
-    // There's a way to tell the bindgen to generate the rust types with custom attributes. Goes in cargo.toml.
-    // Somewhere in the codebase is an example of doing this with serde serialize and deserialize attributes
-    let messages: Vec<Message> = resp_val
-        .into_iter()
-        .map(|m| Message {
-            msg_id: m
-                .msg_id
-                .parse::<u64>()
-                .map_err(|err| QueryResponseParseError.err(&err.to_string()))
-                .unwrap(),
-            receiver: m.receiver,
-            sender: m.sender,
-            subject: m.subject,
-            body: m.body,
-        })
-        .collect();
-    Ok(messages)
+    /// Unsave the message
+    /// - msg_id: the message's rowid (from the events table)
+    ///
+    /// Unsaving a message removing it from state, exposing it to pruning
+    fn unsave(msg_id: u64) -> Result<(), Error> {
+        let msg = get_msg_by_id(msg_id).unwrap();
+        Transact::add_action_to_transaction(
+            "save",
+            &chainmail::action_structs::unsave {
+                subject: msg.subject.clone(),
+                body: msg.body.clone(),
+                msg_id: msg.msg_id,
+                sender: AccountNumber::from(msg.sender.as_str()),
+                datetime: msg.datetime,
+            }
+            .packed(),
+        )?;
+        Ok(())
+    }
 }
 
 impl Query for ChainmailPlugin {
+    /// Retrieve non-archived messages
+    /// - Messages can be filtered by one or both of sender and/or receiver
     fn get_msgs(sender: Option<String>, receiver: Option<String>) -> Result<Vec<Message>, Error> {
         Ok(query_messages_endpoint(sender, receiver, false)?)
     }
 
+    /// Retrieve archived messages
+    /// - Messages can be filtered by one or both of sender and/or receiver
     fn get_archived_msgs(
         sender: Option<String>,
         receiver: Option<String>,

services/user/Chainmail/plugin/src/queries.rs

@@ -0,0 +1,49 @@
+use crate::{
+    bindings::exports::chainmail::plugin::queries::Message,
+    bindings::host::common::{server as CommonServer, types::Error},
+    errors::ErrorType,
+    serde_structs::TempMessageForDeserialization,
+};
+
+pub fn get_msg_by_id(msg_id: u64) -> Result<TempMessageForDeserialization, Error> {
+    let api_root = String::from("/api");
+
+    let res = CommonServer::get_json(&format!("{}/messages?id={}", api_root, &msg_id.to_string()))?;
+
+    let msg = serde_json::from_str::<Vec<TempMessageForDeserialization>>(&res)
+        .map_err(|err| ErrorType::QueryResponseParseError.err(err.to_string().as_str()))?;
+
+    if msg.len() == 1 {
+        let msg = msg.get(0).unwrap();
+        return Ok(msg.clone());
+    } else {
+        return Err(ErrorType::InvalidMsgId.err(&msg_id.to_string()));
+    }
+}
+
+pub fn query_messages_endpoint(
+    sender: Option<String>,
+    receiver: Option<String>,
+    archived_requested: bool,
+) -> Result<Vec<Message>, Error> {
+    let mut endpoint = String::from("/api/messages?");
+    if archived_requested {
+        endpoint += "archived=true&";
+    }
+    if sender.is_some() {
+        endpoint += &format!("sender={}", sender.clone().unwrap());
+    }
+    if sender.is_some() && receiver.is_some() {
+        endpoint += "&";
+    }
+    if receiver.is_some() {
+        endpoint += &format!("receiver={}", receiver.unwrap());
+    }
+
+    let resp = serde_json::from_str::<Vec<TempMessageForDeserialization>>(&CommonServer::get_json(
+        &endpoint,
+    )?)
+    .map_err(|err| ErrorType::QueryResponseParseError.err(err.to_string().as_str()))?;
+
+    Ok(resp.into_iter().map(|m| m.into()).collect())
+}

services/user/Chainmail/plugin/src/serde_structs.rs

@@ -0,0 +1,37 @@
+use psibase::TimePointSec;
+use serde::{de, Deserialize};
+use serde_aux::prelude::*;
+
+use crate::bindings::exports::chainmail::plugin::queries::Message;
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct TempMessageForDeserialization {
+    #[serde(deserialize_with = "deserialize_number_from_string")]
+    pub msg_id: u64,
+    pub receiver: String,
+    pub sender: String,
+    pub subject: String,
+    pub body: String,
+    #[serde(deserialize_with = "deserialize_timepoint")]
+    pub datetime: u32,
+}
+
+fn deserialize_timepoint<'d, D>(deserializer: D) -> Result<u32, D::Error>
+where
+    D: de::Deserializer<'d>,
+{
+    Ok(TimePointSec::deserialize(deserializer)?.seconds)
+}
+
+impl Into<Message> for TempMessageForDeserialization {
+    fn into(self) -> Message {
+        Message {
+            msg_id: self.msg_id,
+            receiver: self.receiver,
+            sender: self.sender,
+            subject: self.subject,
+            body: self.body,
+            datetime: self.datetime,
+        }
+    }
+}

services/user/Chainmail/plugin/wit/world.wit

@@ -6,7 +6,8 @@ interface types {
         receiver: string,
         sender: string,
         subject: string,
-        body: string
+        body: string,
+        datetime: u32
     }
 }
 
@@ -26,6 +27,12 @@ interface api {
 
     // Archive an email
     archive: func(msg-id: u64) -> result<_, error>;
+
+    // Save an email
+    save: func(event-id: u64) -> result<_, error>;
+
+    // Unsave an email (remove it from state)
+    unsave: func(event-id: u64) -> result<_, error>;
 }
 
 world imports {