From 80b656341d8e93cc8f49debf738a123ee1981ca6 Mon Sep 17 00:00:00 2001 From: Gabriel Kaszewski Date: Thu, 14 May 2026 03:23:42 +0200 Subject: [PATCH] feat(domain): ports, events, test helpers --- crates/domain/src/events.rs | 29 +++- crates/domain/src/ports.rs | 139 +++++++++++++++- crates/domain/src/testing.rs | 296 ++++++++++++++++++++++++++++++++++- 3 files changed, 461 insertions(+), 3 deletions(-) diff --git a/crates/domain/src/events.rs b/crates/domain/src/events.rs index 729d0f1..0e7216f 100644 --- a/crates/domain/src/events.rs +++ b/crates/domain/src/events.rs @@ -1 +1,28 @@ -// filled in Task 4 +use crate::value_objects::{UserId, ThoughtId, LikeId, BoostId}; + +#[derive(Debug, Clone)] +pub enum DomainEvent { + ThoughtCreated { thought_id: ThoughtId, user_id: UserId, in_reply_to_id: Option }, + ThoughtDeleted { thought_id: ThoughtId, user_id: UserId }, + ThoughtUpdated { thought_id: ThoughtId, user_id: UserId }, + LikeAdded { like_id: LikeId, user_id: UserId, thought_id: ThoughtId }, + LikeRemoved { user_id: UserId, thought_id: ThoughtId }, + BoostAdded { boost_id: BoostId, user_id: UserId, thought_id: ThoughtId }, + BoostRemoved { user_id: UserId, thought_id: ThoughtId }, + FollowRequested { follower_id: UserId, following_id: UserId }, + FollowAccepted { follower_id: UserId, following_id: UserId }, + FollowRejected { follower_id: UserId, following_id: UserId }, + Unfollowed { follower_id: UserId, following_id: UserId }, + UserBlocked { blocker_id: UserId, blocked_id: UserId }, +} + +pub struct EventEnvelope { + pub event: DomainEvent, + pub ack: Box, + pub nack: Box, +} +impl std::fmt::Debug for EventEnvelope { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("EventEnvelope").field("event", &self.event).finish() + } +} diff --git a/crates/domain/src/ports.rs b/crates/domain/src/ports.rs index 729d0f1..1010659 100644 --- a/crates/domain/src/ports.rs +++ b/crates/domain/src/ports.rs @@ -1 +1,138 @@ -// filled in Task 4 +use async_trait::async_trait; +use crate::{ + errors::DomainError, + events::{DomainEvent, EventEnvelope}, + models::{ + api_key::ApiKey, + feed::{FeedEntry, PageParams, Paginated, UserSummary}, + notification::Notification, + remote_actor::RemoteActor, + social::{Block, Boost, Follow, FollowState, Like}, + tag::Tag, + thought::Thought, + top_friend::TopFriend, + user::User, + }, + value_objects::{ApiKeyId, Content, Email, NotificationId, PasswordHash, ThoughtId, UserId, Username}, +}; + +pub struct GeneratedToken { pub token: String, pub user_id: UserId } + +#[async_trait] +pub trait AuthService: Send + Sync { + fn generate_token(&self, user_id: &UserId) -> Result; + fn validate_token(&self, token: &str) -> Result; +} + +#[async_trait] +pub trait PasswordHasher: Send + Sync { + async fn hash(&self, plain: &str) -> Result; + async fn verify(&self, plain: &str, hash: &PasswordHash) -> Result; +} + +#[async_trait] +pub trait EventPublisher: Send + Sync { + async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError>; +} + +pub trait EventConsumer: Send + Sync { + fn consume(&self) -> futures::stream::BoxStream<'_, Result>; +} + +#[async_trait] +pub trait UserRepository: Send + Sync { + async fn find_by_id(&self, id: &UserId) -> Result, DomainError>; + async fn find_by_username(&self, username: &Username) -> Result, DomainError>; + async fn find_by_email(&self, email: &Email) -> Result, DomainError>; + async fn save(&self, user: &User) -> Result<(), DomainError>; + async fn update_profile(&self, user_id: &UserId, display_name: Option, bio: Option, avatar_url: Option, header_url: Option, custom_css: Option) -> Result<(), DomainError>; + async fn list_with_stats(&self) -> Result, DomainError>; +} + +#[async_trait] +pub trait ThoughtRepository: Send + Sync { + async fn save(&self, thought: &Thought) -> Result<(), DomainError>; + async fn find_by_id(&self, id: &ThoughtId) -> Result, DomainError>; + async fn delete(&self, id: &ThoughtId, user_id: &UserId) -> Result<(), DomainError>; + async fn update_content(&self, id: &ThoughtId, content: &Content) -> Result<(), DomainError>; + async fn get_thread(&self, id: &ThoughtId) -> Result, DomainError>; + async fn list_by_user(&self, user_id: &UserId, page: &PageParams) -> Result, DomainError>; +} + +#[async_trait] +pub trait LikeRepository: Send + Sync { + async fn save(&self, like: &Like) -> Result<(), DomainError>; + async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError>; + async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result, DomainError>; + async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result; +} + +#[async_trait] +pub trait BoostRepository: Send + Sync { + async fn save(&self, boost: &Boost) -> Result<(), DomainError>; + async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError>; + async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result, DomainError>; + async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result; +} + +#[async_trait] +pub trait FollowRepository: Send + Sync { + async fn save(&self, follow: &Follow) -> Result<(), DomainError>; + async fn delete(&self, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError>; + async fn find(&self, follower_id: &UserId, following_id: &UserId) -> Result, DomainError>; + async fn update_state(&self, follower_id: &UserId, following_id: &UserId, state: &FollowState) -> Result<(), DomainError>; + async fn list_followers(&self, user_id: &UserId, page: &PageParams) -> Result, DomainError>; + async fn list_following(&self, user_id: &UserId, page: &PageParams) -> Result, DomainError>; + async fn get_accepted_following_ids(&self, user_id: &UserId) -> Result, DomainError>; +} + +#[async_trait] +pub trait BlockRepository: Send + Sync { + async fn save(&self, block: &Block) -> Result<(), DomainError>; + async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError>; + async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result; +} + +#[async_trait] +pub trait TagRepository: Send + Sync { + async fn find_or_create(&self, name: &str) -> Result; + async fn attach_to_thought(&self, thought_id: &ThoughtId, tag_id: i32) -> Result<(), DomainError>; + async fn detach_from_thought(&self, thought_id: &ThoughtId) -> Result<(), DomainError>; + async fn list_for_thought(&self, thought_id: &ThoughtId) -> Result, DomainError>; + async fn list_thoughts_by_tag(&self, tag_name: &str, page: &PageParams) -> Result, DomainError>; +} + +#[async_trait] +pub trait ApiKeyRepository: Send + Sync { + async fn save(&self, key: &ApiKey) -> Result<(), DomainError>; + async fn find_by_hash(&self, key_hash: &str) -> Result, DomainError>; + async fn list_for_user(&self, user_id: &UserId) -> Result, DomainError>; + async fn delete(&self, id: &ApiKeyId, user_id: &UserId) -> Result<(), DomainError>; +} + +#[async_trait] +pub trait TopFriendRepository: Send + Sync { + async fn set_top_friends(&self, user_id: &UserId, friends: Vec<(UserId, i16)>) -> Result<(), DomainError>; + async fn list_for_user(&self, user_id: &UserId) -> Result, DomainError>; +} + +#[async_trait] +pub trait NotificationRepository: Send + Sync { + async fn save(&self, n: &Notification) -> Result<(), DomainError>; + async fn list_for_user(&self, user_id: &UserId, page: &PageParams) -> Result, DomainError>; + async fn mark_read(&self, id: &NotificationId, user_id: &UserId) -> Result<(), DomainError>; + async fn mark_all_read(&self, user_id: &UserId) -> Result<(), DomainError>; +} + +#[async_trait] +pub trait RemoteActorRepository: Send + Sync { + async fn upsert(&self, actor: &RemoteActor) -> Result<(), DomainError>; + async fn find_by_url(&self, url: &str) -> Result, DomainError>; +} + +#[async_trait] +pub trait FeedRepository: Send + Sync { + async fn home_feed(&self, following_ids: &[UserId], page: &PageParams, viewer_id: Option<&UserId>) -> Result, DomainError>; + async fn public_feed(&self, page: &PageParams, viewer_id: Option<&UserId>) -> Result, DomainError>; + async fn search(&self, query: &str, page: &PageParams, viewer_id: Option<&UserId>) -> Result, DomainError>; +} diff --git a/crates/domain/src/testing.rs b/crates/domain/src/testing.rs index 729d0f1..ba5a23b 100644 --- a/crates/domain/src/testing.rs +++ b/crates/domain/src/testing.rs @@ -1 +1,295 @@ -// filled in Task 4 +use std::sync::{Arc, Mutex}; +use async_trait::async_trait; +use chrono::Utc; +use crate::{ + errors::DomainError, + events::DomainEvent, + models::{ + api_key::ApiKey, + feed::{FeedEntry, PageParams, Paginated, UserSummary}, + notification::Notification, + remote_actor::RemoteActor, + social::{Block, Boost, Follow, FollowState, Like}, + tag::Tag, + thought::Thought, + top_friend::TopFriend, + user::User, + }, + ports::*, + value_objects::{ApiKeyId, Content, Email, NotificationId, ThoughtId, UserId, Username}, +}; + +#[derive(Default, Clone)] +pub struct TestStore { + pub users: Arc>>, + pub thoughts: Arc>>, + pub likes: Arc>>, + pub boosts: Arc>>, + pub follows: Arc>>, + pub blocks: Arc>>, + pub tags: Arc>>, + pub api_keys: Arc>>, + pub top_friends: Arc>>, + pub notifications: Arc>>, + pub events: Arc>>, +} + +#[async_trait] impl UserRepository for TestStore { + async fn find_by_id(&self, id: &UserId) -> Result, DomainError> { + Ok(self.users.lock().unwrap().iter().find(|u| &u.id == id).cloned()) + } + async fn find_by_username(&self, username: &Username) -> Result, DomainError> { + Ok(self.users.lock().unwrap().iter().find(|u| u.username.as_str() == username.as_str()).cloned()) + } + async fn find_by_email(&self, email: &Email) -> Result, DomainError> { + Ok(self.users.lock().unwrap().iter().find(|u| u.email.as_str() == email.as_str()).cloned()) + } + async fn save(&self, user: &User) -> Result<(), DomainError> { + let mut g = self.users.lock().unwrap(); + g.retain(|u| u.id != user.id); + g.push(user.clone()); + Ok(()) + } + async fn update_profile(&self, user_id: &UserId, display_name: Option, bio: Option, avatar_url: Option, header_url: Option, custom_css: Option) -> Result<(), DomainError> { + if let Some(u) = self.users.lock().unwrap().iter_mut().find(|u| &u.id == user_id) { + u.display_name = display_name; + u.bio = bio; + u.avatar_url = avatar_url; + u.header_url = header_url; + u.custom_css = custom_css; + } + Ok(()) + } + async fn list_with_stats(&self) -> Result, DomainError> { Ok(vec![]) } +} + +#[async_trait] impl ThoughtRepository for TestStore { + async fn save(&self, t: &Thought) -> Result<(), DomainError> { + let mut g = self.thoughts.lock().unwrap(); + g.retain(|x| x.id != t.id); + g.push(t.clone()); + Ok(()) + } + async fn find_by_id(&self, id: &ThoughtId) -> Result, DomainError> { + Ok(self.thoughts.lock().unwrap().iter().find(|t| &t.id == id).cloned()) + } + async fn delete(&self, id: &ThoughtId, user_id: &UserId) -> Result<(), DomainError> { + let mut g = self.thoughts.lock().unwrap(); + let before = g.len(); + g.retain(|t| !(&t.id == id && &t.user_id == user_id)); + if g.len() == before { return Err(DomainError::NotFound); } + Ok(()) + } + async fn update_content(&self, id: &ThoughtId, content: &Content) -> Result<(), DomainError> { + if let Some(t) = self.thoughts.lock().unwrap().iter_mut().find(|t| &t.id == id) { + t.content = content.clone(); + t.updated_at = Some(Utc::now()); + } + Ok(()) + } + async fn get_thread(&self, id: &ThoughtId) -> Result, DomainError> { + Ok(self.thoughts.lock().unwrap().iter() + .filter(|t| t.in_reply_to_id.as_ref() == Some(id) || &t.id == id) + .cloned().collect()) + } + async fn list_by_user(&self, _user_id: &UserId, _page: &PageParams) -> Result, DomainError> { + Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 }) + } +} + +#[async_trait] impl LikeRepository for TestStore { + async fn save(&self, like: &Like) -> Result<(), DomainError> { + let mut g = self.likes.lock().unwrap(); + if g.iter().any(|l| l.user_id == like.user_id && l.thought_id == like.thought_id) { + return Err(DomainError::Conflict("already liked".into())); + } + g.push(like.clone()); + Ok(()) + } + async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> { + let mut g = self.likes.lock().unwrap(); + let before = g.len(); + g.retain(|l| !(&l.user_id == user_id && &l.thought_id == thought_id)); + if g.len() == before { return Err(DomainError::NotFound); } + Ok(()) + } + async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result, DomainError> { + Ok(self.likes.lock().unwrap().iter().find(|l| &l.user_id == user_id && &l.thought_id == thought_id).cloned()) + } + async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result { + Ok(self.likes.lock().unwrap().iter().filter(|l| &l.thought_id == thought_id).count() as i64) + } +} + +#[async_trait] impl BoostRepository for TestStore { + async fn save(&self, boost: &Boost) -> Result<(), DomainError> { + let mut g = self.boosts.lock().unwrap(); + if g.iter().any(|b| b.user_id == boost.user_id && b.thought_id == boost.thought_id) { + return Err(DomainError::Conflict("already boosted".into())); + } + g.push(boost.clone()); + Ok(()) + } + async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> { + let mut g = self.boosts.lock().unwrap(); + let before = g.len(); + g.retain(|b| !(&b.user_id == user_id && &b.thought_id == thought_id)); + if g.len() == before { return Err(DomainError::NotFound); } + Ok(()) + } + async fn find(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result, DomainError> { + Ok(self.boosts.lock().unwrap().iter().find(|b| &b.user_id == user_id && &b.thought_id == thought_id).cloned()) + } + async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result { + Ok(self.boosts.lock().unwrap().iter().filter(|b| &b.thought_id == thought_id).count() as i64) + } +} + +#[async_trait] impl FollowRepository for TestStore { + async fn save(&self, follow: &Follow) -> Result<(), DomainError> { + let mut g = self.follows.lock().unwrap(); + g.retain(|f| !(f.follower_id == follow.follower_id && f.following_id == follow.following_id)); + g.push(follow.clone()); + Ok(()) + } + async fn delete(&self, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> { + let mut g = self.follows.lock().unwrap(); + let before = g.len(); + g.retain(|f| !(&f.follower_id == follower_id && &f.following_id == following_id)); + if g.len() == before { return Err(DomainError::NotFound); } + Ok(()) + } + async fn find(&self, follower_id: &UserId, following_id: &UserId) -> Result, DomainError> { + Ok(self.follows.lock().unwrap().iter().find(|f| &f.follower_id == follower_id && &f.following_id == following_id).cloned()) + } + async fn update_state(&self, follower_id: &UserId, following_id: &UserId, state: &FollowState) -> Result<(), DomainError> { + if let Some(f) = self.follows.lock().unwrap().iter_mut().find(|f| &f.follower_id == follower_id && &f.following_id == following_id) { + f.state = state.clone(); + } + Ok(()) + } + async fn list_followers(&self, _user_id: &UserId, _p: &PageParams) -> Result, DomainError> { + Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 }) + } + async fn list_following(&self, _user_id: &UserId, _p: &PageParams) -> Result, DomainError> { + Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 }) + } + async fn get_accepted_following_ids(&self, user_id: &UserId) -> Result, DomainError> { + Ok(self.follows.lock().unwrap().iter() + .filter(|f| &f.follower_id == user_id && f.state == FollowState::Accepted) + .map(|f| f.following_id.clone()) + .collect()) + } +} + +#[async_trait] impl BlockRepository for TestStore { + async fn save(&self, block: &Block) -> Result<(), DomainError> { + self.blocks.lock().unwrap().push(block.clone()); + Ok(()) + } + async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> { + self.blocks.lock().unwrap().retain(|b| !(&b.blocker_id == blocker_id && &b.blocked_id == blocked_id)); + Ok(()) + } + async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result { + Ok(self.blocks.lock().unwrap().iter().any(|b| &b.blocker_id == blocker_id && &b.blocked_id == blocked_id)) + } +} + +#[async_trait] impl TagRepository for TestStore { + async fn find_or_create(&self, name: &str) -> Result { + let mut g = self.tags.lock().unwrap(); + if let Some(t) = g.iter().find(|t| t.name == name) { return Ok(t.clone()); } + let tag = Tag { id: g.len() as i32 + 1, name: name.to_string() }; + g.push(tag.clone()); + Ok(tag) + } + async fn attach_to_thought(&self, _tid: &ThoughtId, _tag_id: i32) -> Result<(), DomainError> { Ok(()) } + async fn detach_from_thought(&self, _tid: &ThoughtId) -> Result<(), DomainError> { Ok(()) } + async fn list_for_thought(&self, _tid: &ThoughtId) -> Result, DomainError> { Ok(vec![]) } + async fn list_thoughts_by_tag(&self, _name: &str, _p: &PageParams) -> Result, DomainError> { + Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 }) + } +} + +#[async_trait] impl ApiKeyRepository for TestStore { + async fn save(&self, key: &ApiKey) -> Result<(), DomainError> { + self.api_keys.lock().unwrap().push(key.clone()); + Ok(()) + } + async fn find_by_hash(&self, hash: &str) -> Result, DomainError> { + Ok(self.api_keys.lock().unwrap().iter().find(|k| k.key_hash == hash).cloned()) + } + async fn list_for_user(&self, uid: &UserId) -> Result, DomainError> { + Ok(self.api_keys.lock().unwrap().iter().filter(|k| &k.user_id == uid).cloned().collect()) + } + async fn delete(&self, id: &ApiKeyId, uid: &UserId) -> Result<(), DomainError> { + self.api_keys.lock().unwrap().retain(|k| !(&k.id == id && &k.user_id == uid)); + Ok(()) + } +} + +#[async_trait] impl TopFriendRepository for TestStore { + async fn set_top_friends(&self, user_id: &UserId, friends: Vec<(UserId, i16)>) -> Result<(), DomainError> { + let mut g = self.top_friends.lock().unwrap(); + g.retain(|tf| &tf.user_id != user_id); + for (fid, pos) in friends { + g.push(TopFriend { user_id: user_id.clone(), friend_id: fid, position: pos }); + } + Ok(()) + } + async fn list_for_user(&self, _uid: &UserId) -> Result, DomainError> { Ok(vec![]) } +} + +#[async_trait] impl NotificationRepository for TestStore { + async fn save(&self, n: &Notification) -> Result<(), DomainError> { + self.notifications.lock().unwrap().push(n.clone()); + Ok(()) + } + async fn list_for_user(&self, uid: &UserId, _p: &PageParams) -> Result, DomainError> { + let items: Vec<_> = self.notifications.lock().unwrap().iter().filter(|n| &n.user_id == uid).cloned().collect(); + let total = items.len() as i64; + Ok(Paginated { items, total, page: 1, per_page: 20 }) + } + async fn mark_read(&self, id: &NotificationId, _uid: &UserId) -> Result<(), DomainError> { + if let Some(n) = self.notifications.lock().unwrap().iter_mut().find(|n| &n.id == id) { + n.read = true; + } + Ok(()) + } + async fn mark_all_read(&self, uid: &UserId) -> Result<(), DomainError> { + for n in self.notifications.lock().unwrap().iter_mut().filter(|n| &n.user_id == uid) { + n.read = true; + } + Ok(()) + } +} + +#[async_trait] impl RemoteActorRepository for TestStore { + async fn upsert(&self, _a: &RemoteActor) -> Result<(), DomainError> { Ok(()) } + async fn find_by_url(&self, _url: &str) -> Result, DomainError> { Ok(None) } +} + +#[async_trait] impl FeedRepository for TestStore { + async fn home_feed(&self, _ids: &[UserId], _p: &PageParams, _v: Option<&UserId>) -> Result, DomainError> { + Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 }) + } + async fn public_feed(&self, _p: &PageParams, _v: Option<&UserId>) -> Result, DomainError> { + Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 }) + } + async fn search(&self, _q: &str, _p: &PageParams, _v: Option<&UserId>) -> Result, DomainError> { + Ok(Paginated { items: vec![], total: 0, page: 1, per_page: 20 }) + } +} + +#[async_trait] impl EventPublisher for TestStore { + async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> { + self.events.lock().unwrap().push(event.clone()); + Ok(()) + } +} + +pub struct NoOpEventPublisher; +#[async_trait] impl EventPublisher for NoOpEventPublisher { + async fn publish(&self, _e: &DomainEvent) -> Result<(), DomainError> { Ok(()) } +}