Refactor for domain clarity

src/actors/event_enqueuer.rs

@@ -1,5 +1,5 @@
 use crate::actors::messages::EventEnqueuerMessage;
-use crate::actors::messages::ReportRequest;
+use crate::domain_objects::ReportRequest;
 use anyhow::Result;
 use ractor::{Actor, ActorProcessingErr, ActorRef};
 use tracing::{error, info};
@@ -115,6 +115,7 @@ mod tests {
 
  let report_request_string = json!({
  "reportedEvent": event_to_report,
+ "reporterPubkey": Keys::generate().public_key().to_string(),
  "reporterText": "This is hateful. Report it!"
  })
  .to_string();

src/actors/gift_unwrapper.rs

@@ -1,4 +1,5 @@
-use crate::actors::messages::{GiftUnwrapperMessage, ReportRequest};
+use crate::actors::messages::GiftUnwrapperMessage;
+use crate::domain_objects::ReportRequest;
 use anyhow::Result;
 use nostr_sdk::prelude::*;
 use ractor::{Actor, ActorProcessingErr, ActorRef, OutputPort};
@@ -41,33 +42,21 @@ impl Actor for GiftUnwrapper {
  match message {
  // Decrypts and forwards private messages to the output port.
  GiftUnwrapperMessage::UnwrapEvent(gift_wrap) => {
- let unwrapped_gift = match gift_wrap.extract_rumor(&state.keys) {
- Ok(gift) => gift,
+ let report_request = match gift_wrap.extract_report_request(&state.keys) {
+ Ok(report_request) => report_request,
  Err(e) => {
- error!("Error extracting rumor: {}", e);
+ error!("Error extracting report: {}", e);
  return Ok(());
  }
  };
 
- match serde_json::from_str::<ReportRequest>(&unwrapped_gift.rumor.content) {
- Ok(report_request) => {
- info!(
- "Request from {} to moderate event {}",
- unwrapped_gift.sender,
- report_request.reported_event.id()
- );
+ info!(
+ "Request from {} to moderate event {}",
+ report_request.reporter_pubkey,
+ report_request.reported_event.id()
+ );
 
- if !report_request.valid() {
- error!("Invalid report request");
- return Ok(());
- }
-
- state.message_parsed_output_port.send(report_request)
- }
- Err(e) => {
- error!("Error parsing event from {}, {}", unwrapped_gift.sender, e);
- }
- }
+ state.message_parsed_output_port.send(report_request)
  }
 
  // Subscribes a new actor to receive parsed messages through the output port.
@@ -90,12 +79,10 @@ pub async fn create_private_dm_message(
  reporter_keys: &Keys,
  receiver_pubkey: &PublicKey,
 ) -> Result<Event> {
- if let Some(reporter_pubkey) = &report_request.reporter_pubkey {
- if reporter_pubkey != &reporter_keys.public_key() {
- return Err(anyhow::anyhow!(
- "Reporter public key doesn't match the provided keys"
- ));
- }
+ if report_request.reporter_pubkey != reporter_keys.public_key() {
+ return Err(anyhow::anyhow!(
+ "Reporter public key doesn't match the provided keys"
+ ));
  }
  // Compose rumor
  let kind_14_rumor =
@@ -118,8 +105,8 @@ pub async fn create_private_dm_message(
 #[cfg(test)]
 mod tests {
  use super::*;
- use crate::actors::messages::GiftWrap;
  use crate::actors::TestActor;
+ use crate::domain_objects::GiftWrap;
  use ractor::{cast, Actor};
  use serde_json::json;
  use std::sync::Arc;

src/actors/messages.rs

@@ -1,22 +1,7 @@
 use crate::actors::utilities::OutputPortSubscriber;
-use anyhow::{Context, Result};
-use nostr_sdk::prelude::*;
-use serde::{Deserialize, Serialize};
+use crate::domain_objects::*;
 use std::fmt::Debug;
 
-//Newtype
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct GiftWrap(Event);
-impl GiftWrap {
- pub fn new(event: Event) -> Self {
- GiftWrap(event)
- }
-
- pub fn extract_rumor(&self, keys: &Keys) -> Result<UnwrappedGift> {
- extract_rumor(keys, &self.0).context("Couldn't extract rumor")
- }
-}
-
 #[derive(Debug)]
 pub enum RelayEventDispatcherMessage {
  Connect,
@@ -38,24 +23,6 @@ impl From<GiftWrap> for GiftUnwrapperMessage {
  }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ReportRequest {
- pub reported_event: Event,
- pub reporter_pubkey: Option<PublicKey>,
- pub reporter_text: Option<String>,
-}
-
-impl ReportRequest {
- pub fn as_json(&self) -> String {
- serde_json::to_string(self).expect("Failed to serialize ReportRequest to JSON")
- }
-
- pub fn valid(&self) -> bool {
- self.reporter_pubkey.is_some() && self.reported_event.verify().is_ok()
- }
-}
-
 #[derive(Debug)]
 pub enum EventEnqueuerMessage {
  Enqueue(ReportRequest),

src/actors/relay_event_dispatcher.rs

@@ -1,5 +1,5 @@
-use super::messages::GiftWrap;
 use crate::actors::messages::RelayEventDispatcherMessage;
+use crate::domain_objects::GiftWrap;
 use crate::service_manager::ServiceManager;
 use anyhow::Result;
 use nostr_sdk::prelude::*;

src/adapters/google_publisher.rs

@@ -1,5 +1,5 @@
-use crate::actors::messages::ReportRequest;
 use crate::actors::PubsubPublisher;
+use crate::domain_objects::ReportRequest;
 use anyhow::{Context, Result};
 use gcloud_sdk::{
  google::pubsub::v1::{publisher_client::PublisherClient, PublishRequest, PubsubMessage},

src/adapters/nostr_subscriber.rs

@@ -1,6 +1,6 @@
-use crate::actors::messages::GiftWrap;
 use crate::actors::messages::RelayEventDispatcherMessage;
 use crate::actors::Subscribe;
+use crate::domain_objects::GiftWrap;
 use nostr_sdk::prelude::*;
 use ractor::{cast, concurrency::Duration, ActorRef};
 use tokio_util::sync::CancellationToken;

src/bin/giftwrapper.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use nostr_sdk::prelude::*;
 use reportinator_server::actors::gift_unwrapper::create_private_dm_message;
-use reportinator_server::actors::messages::ReportRequest;
+use reportinator_server::domain_objects::ReportRequest;
 use std::env;
 use std::io::{self, BufRead};
 use std::str::FromStr;
@@ -32,7 +32,7 @@ async fn main() -> Result<()> {
  let sender_keys = Keys::generate();
  let report_request = ReportRequest {
  reported_event: EventBuilder::text_note(&message, []).to_event(&sender_keys)?,
- reporter_pubkey: Some(sender_keys.public_key()),
+ reporter_pubkey: sender_keys.public_key(),
  reporter_text: Some("This is wrong, report it!".to_string()),
  };
  let event_result =

src/domain_objects.rs

@@ -0,0 +1,47 @@
+use anyhow::{bail, Context, Result};
+use nostr_sdk::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::fmt::Debug;
+
+//Newtype
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GiftWrap(Event);
+impl GiftWrap {
+ pub fn new(event: Event) -> Self {
+ GiftWrap(event)
+ }
+
+ pub fn extract_report_request(&self, keys: &Keys) -> Result<ReportRequest> {
+ let unwrapped_gift = self.extract_rumor(keys)?;
+ let report_request = serde_json::from_str::<ReportRequest>(&unwrapped_gift.rumor.content)
+ .context("Failed to parse report request")?;
+
+ if !report_request.valid() {
+ bail!("Invalid report request");
+ }
+
+ Ok(report_request)
+ }
+
+ fn extract_rumor(&self, keys: &Keys) -> Result<UnwrappedGift> {
+ extract_rumor(keys, &self.0).context("Couldn't extract rumor")
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReportRequest {
+ pub reported_event: Event,
+ pub reporter_pubkey: PublicKey,
+ pub reporter_text: Option<String>,
+}
+
+impl ReportRequest {
+ pub fn as_json(&self) -> String {
+ serde_json::to_string(self).expect("Failed to serialize ReportRequest to JSON")
+ }
+
+ pub fn valid(&self) -> bool {
+ self.reported_event.verify().is_ok()
+ }
+}

src/lib.rs

@@ -1,2 +1,3 @@
 pub mod actors;
+pub mod domain_objects;
 pub mod service_manager;

src/main.rs

@@ -1,6 +1,8 @@
 mod actors;
 mod adapters;
+mod domain_objects;
 mod service_manager;
+
 use crate::actors::{
  messages::{GiftUnwrapperMessage, RelayEventDispatcherMessage},
  EventEnqueuer, GiftUnwrapper, RelayEventDispatcher, Subscribe,