๐ End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Add encrypted post comments, replies, and reactions
Anand Baburajan51d6427a7496
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rsindex 27e6ff933f..063aee694b 100644--- a/rust/bindings/wasm/space/src/space.rs+++ b/rust/bindings/wasm/space/src/space.rs@@ -326,6 +326,7 @@ pub struct PostResponse {is_unavailable: bool,created_at: String,viewer_liked: bool,+ comment_count: i64,}#[derive(Serialize, Tsify)]@@ -338,6 +339,10 @@ pub struct PostPage {#[derive(Serialize, Tsify)]#[serde(rename_all = "camelCase")]pub struct Notification {+ post_space_id: Option<String>,+ post_owner_slug: Option<String>,+ comment_id: Option<String>,+ reply_to_id: Option<String>,notification_id: String,notification_ids: Vec<String>,kind: String,@@ -366,6 +371,10 @@ impl From<ente_space::NotificationPage> for NotificationPage {.into_iter().map(|item| Notification {notification_id: item.notification_id,+ post_space_id: item.post_space_id,+ post_owner_slug: item.post_owner_slug,+ comment_id: item.comment_id,+ reply_to_id: item.reply_to_id,notification_ids: item.notification_ids,kind: item.kind,actors: item.actors.into_iter().map(Into::into).collect(),@@ -713,6 +722,7 @@ impl From<ente_space::Post> for PostResponse {is_unavailable,created_at: post.created_at,viewer_liked: post.viewer_liked,+ comment_count: post.comment_count,}}}@@ -1487,6 +1497,94 @@ impl SpaceAccountCtxHandle {MessageResponse::from(message).into_js().map_err(Into::into)}+ #[wasm_bindgen(js_name = listComments)]+ pub async fn list_comments(+ &self,+ viewer: String,+ post_space_id: String,+ post_id: i64,+ cursor: Option<String>,+ ) -> Result<<CommentPage as Tsify>::JsType, Error> {+ CommentPage::from(+ self.inner+ .list_comments(&viewer, &post_space_id, post_id, cursor.as_deref())+ .await?,+ )+ .into_js()+ .map_err(Into::into)+ }++ #[wasm_bindgen(js_name = createComment)]+ pub async fn create_comment(+ &self,+ viewer: String,+ post_space_id: String,+ post_id: i64,+ comment_id: String,+ reply_to_id: Option<String>,+ text: String,+ ) -> Result<(), Error> {+ self.inner+ .create_comment(+ &viewer,+ &post_space_id,+ post_id,+ &comment_id,+ reply_to_id.as_deref(),+ &text,+ )+ .await+ .map_err(Into::into)+ }++ #[wasm_bindgen(js_name = deleteComment)]+ pub async fn delete_comment(+ &self,+ viewer: String,+ post_id: i64,+ comment_id: String,+ ) -> Result<(), Error> {+ self.inner+ .delete_comment(&viewer, post_id, &comment_id)+ .await+ .map_err(Into::into)+ }++ #[wasm_bindgen(js_name = removeCommentReaction)]+ pub async fn remove_comment_reaction(+ &self,+ viewer: String,+ post_id: i64,+ comment_id: String,+ actor_space_id: String,+ ) -> Result<(), Error> {+ self.inner+ .remove_comment_reaction(&viewer, post_id, &comment_id, &actor_space_id)+ .await+ .map_err(Into::into)+ }++ #[wasm_bindgen(js_name = setCommentReaction)]+ pub async fn set_comment_reaction(+ &self,+ viewer: String,+ post_space_id: String,+ post_id: i64,+ comment_id: String,+ emoji: Option<String>,+ ) -> Result<(), Error> {+ self.inner+ .set_comment_reaction(+ &viewer,+ &post_space_id,+ post_id,+ &comment_id,+ emoji.as_deref(),+ )+ .await+ .map_err(Into::into)+ }+#[wasm_bindgen(js_name = replyToPost)]pub async fn reply_to_post(&self,@@ -1665,3 +1763,65 @@ impl SpaceAccountCtxHandle {.map_err(Into::into)}}++#[derive(Serialize, Tsify)]+#[serde(rename_all = "camelCase")]+pub struct CommentReaction {+ actor: SpaceActorResponse,+ emoji: String,+ is_own: bool,+}++#[derive(Serialize, Tsify)]+#[serde(rename_all = "camelCase")]+pub struct Comment {+ comment_id: String,+ unread_notification_ids: Vec<String>,+ author: Option<SpaceActorResponse>,+ parent_id: String,+ reply_to_id: String,+ text: Option<String>,+ deleted: bool,+ created_at: String,+ can_delete: bool,+ reactions: Vec<CommentReaction>,+}++#[derive(Serialize, Tsify)]+#[serde(rename_all = "camelCase")]+pub struct CommentPage {+ items: Vec<Comment>,+ next_cursor: String,+}++impl From<ente_space::models::CommentPage> for CommentPage {+ fn from(page: ente_space::models::CommentPage) -> Self {+ Self {+ next_cursor: page.next_cursor,+ items: page+ .items+ .into_iter()+ .map(|item| Comment {+ comment_id: item.comment_id,+ unread_notification_ids: item.unread_notification_ids,+ author: item.author.map(Into::into),+ parent_id: item.parent_id,+ reply_to_id: item.reply_to_id,+ text: item.text,+ deleted: item.deleted,+ created_at: item.created_at,+ can_delete: item.can_delete,+ reactions: item+ .reactions+ .into_iter()+ .map(|reaction| CommentReaction {+ actor: reaction.actor.into(),+ emoji: reaction.emoji,+ is_own: reaction.is_own,+ })+ .collect(),+ })+ .collect(),+ }+ }+}diff --git a/rust/crates/space/src/client/comments.rs b/rust/crates/space/src/client/comments.rsnew file mode 100644index 0000000000..4949a5d1b8--- /dev/null+++ b/rust/crates/space/src/client/comments.rs@@ -0,0 +1,504 @@+use super::{AccountSpaceCtx, retain_content_error};+use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload};+use crate::error::{Error, Result};+use crate::models::{Comment, CommentPage, CommentReaction, SpaceActor};+use crate::transport::CommentPageResponse;+use ente_core::{b64, crypto::SecretVec};+use serde::{Deserialize, Serialize};++#[derive(Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+struct DiscussionPayload {+ kind: String,+ post_id: i64,+ comment_id: String,+ author_space_id: String,+ reply_to_id: String,+ text: String,+}++fn encrypt_contribution(key: &[u8], payload: &DiscussionPayload) -> Result<String> {+ let bytes =+ serde_json::to_vec(payload).map_err(|_| Error::InvalidInput("invalid comment".into()))?;+ Ok(b64::encode(&encrypt_secretbox_payload(key, &bytes)?))+}++fn decrypt_contribution(key: &[u8], cipher: &str, expected: &DiscussionPayload) -> Result<String> {+ let plaintext = decrypt_secretbox_payload(key, &b64::decode(cipher)?)?;+ let payload: DiscussionPayload = serde_json::from_slice(&plaintext)+ .map_err(|_| Error::InvalidInput("invalid comment".into()))?;+ if payload.kind != expected.kind+ || payload.post_id != expected.post_id+ || payload.comment_id != expected.comment_id+ || payload.author_space_id != expected.author_space_id+ || payload.reply_to_id != expected.reply_to_id+ {+ return Err(Error::InvalidInput("discussion context mismatch".into()));+ }+ validate_contribution(&payload.kind, &payload.text)?;+ Ok(payload.text)+}++fn validate_contribution(kind: &str, text: &str) -> Result<()> {+ if kind == "reaction" {+ return super::reactions::validate_emoji(text);+ }+ if text.trim().is_empty()+ || text.chars().count() > super::MAX_SPACE_MESSAGE_TEXT_CHARS+ || text.len() > super::MAX_SPACE_MESSAGE_TEXT_BYTES+ {+ return Err(Error::InvalidInput("comment is empty or too long".into()));+ }+ Ok(())+}++fn validate_comment_id(comment_id: &str) -> Result<()> {+ if comment_id.is_empty()+ || comment_id.len() > 64+ || !comment_id+ .bytes()+ .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-' || byte == b'_')+ {+ return Err(Error::InvalidInput("invalid comment ID".into()));+ }+ Ok(())+}++fn comment_path(viewer: &str, post_id: i64, comment_id: &str) -> Result<String> {+ validate_comment_id(comment_id)?;+ Ok(format!(+ "/spaces/{}/discussions/{post_id}/comments/{}",+ urlencoding::encode(viewer),+ urlencoding::encode(comment_id)+ ))+}++impl AccountSpaceCtx {+ async fn comment_post_key(+ &self,+ viewer: &str,+ post_space_id: &str,+ post_id: i64,+ ) -> Result<SecretVec> {+ let post = self+ .get_post_raw(post_space_id, post_id, Some(viewer))+ .await?;+ Ok(SecretVec::new(+ self.decrypt_post_key_fields(+ &post.space_id,+ Some(viewer),+ &post.encrypted_post_key,+ post.key_version,+ )+ .await?,+ ))+ }++ pub async fn list_comments(+ &self,+ viewer: &str,+ post_space_id: &str,+ post_id: i64,+ cursor: Option<&str>,+ ) -> Result<CommentPage> {+ let path = format!(+ "/spaces/{}/discussions/{post_id}/comments",+ urlencoding::encode(viewer)+ );+ let query = cursor+ .map(|cursor| vec![("cursor", cursor)])+ .unwrap_or_default();+ let page: CommentPageResponse = self+ .api()+ .get(&path)+ .query(&query)+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?;+ let key = self+ .comment_post_key(viewer, post_space_id, post_id)+ .await?;+ let mut items = Vec::new();+ for comment in page.items {+ let deleted = comment.cipher.is_empty() || comment.author.is_none();+ let text = if let Some(author) = comment.author.as_ref().filter(|_| !deleted) {+ let expected = DiscussionPayload {+ kind: "comment".into(),+ post_id,+ comment_id: comment.comment_id.clone(),+ author_space_id: author.space_id.clone(),+ reply_to_id: comment.reply_to_id.clone(),+ text: String::new(),+ };+ retain_content_error(decrypt_contribution(&key, &comment.cipher, &expected))?.ok()+ } else {+ None+ };+ let mut reactions = Vec::new();+ for reaction in comment.reactions {+ let expected = DiscussionPayload {+ kind: "reaction".into(),+ post_id,+ comment_id: comment.comment_id.clone(),+ author_space_id: reaction.actor.space_id.clone(),+ reply_to_id: String::new(),+ text: String::new(),+ };+ if let Ok(emoji) =+ retain_content_error(decrypt_contribution(&key, &reaction.cipher, &expected))?+ {+ let profile =+ retain_content_error(self.decrypt_actor_profile(&reaction.actor).await)?;+ reactions.push(CommentReaction {+ actor: SpaceActor::from_response(reaction.actor, profile),+ emoji,+ is_own: reaction.is_own,+ });+ }+ }+ let author = if let Some(author) = comment.author {+ let profile = retain_content_error(self.decrypt_actor_profile(&author).await)?;+ Some(SpaceActor::from_response(author, profile))+ } else {+ None+ };+ items.push(Comment {+ comment_id: comment.comment_id,+ unread_notification_ids: comment.unread_notification_ids,+ author,+ parent_id: comment.parent_id,+ reply_to_id: comment.reply_to_id,+ text,+ deleted,+ created_at: comment.created_at,+ can_delete: comment.can_delete,+ reactions,+ });+ }+ Ok(CommentPage {+ items,+ next_cursor: page.next_cursor,+ })+ }++ pub async fn create_comment(+ &self,+ viewer: &str,+ post_space_id: &str,+ post_id: i64,+ comment_id: &str,+ reply_to_id: Option<&str>,+ text: &str,+ ) -> Result<()> {+ validate_comment_id(comment_id)?;+ let reply_to_id = reply_to_id.unwrap_or_default();+ if !reply_to_id.is_empty() {+ validate_comment_id(reply_to_id)?;+ }+ validate_contribution("comment", text)?;+ let key = self+ .comment_post_key(viewer, post_space_id, post_id)+ .await?;+ let payload = DiscussionPayload {+ kind: "comment".into(),+ post_id,+ comment_id: comment_id.into(),+ author_space_id: viewer.into(),+ reply_to_id: reply_to_id.into(),+ text: text.into(),+ };+ self.api().post(&format!("/spaces/{}/discussions/{post_id}/comments", urlencoding::encode(viewer)))+ .json(&serde_json::json!({"commentId":comment_id, "replyToId":reply_to_id, "cipher":encrypt_contribution(&key, &payload)?}))+ .send().await?.error_for_status()?;+ Ok(())+ }++ pub async fn delete_comment(&self, viewer: &str, post_id: i64, comment_id: &str) -> Result<()> {+ self.api()+ .delete(&comment_path(viewer, post_id, comment_id)?)+ .send()+ .await?+ .error_for_status()?;+ Ok(())+ }++ pub async fn remove_comment_reaction(+ &self,+ viewer: &str,+ post_id: i64,+ comment_id: &str,+ actor_space_id: &str,+ ) -> Result<()> {+ self.api()+ .delete(&format!(+ "{}/reaction",+ comment_path(viewer, post_id, comment_id)?+ ))+ .query(&[("actorSpaceId", actor_space_id)])+ .send()+ .await?+ .error_for_status()?;+ Ok(())+ }++ pub async fn set_comment_reaction(+ &self,+ viewer: &str,+ post_space_id: &str,+ post_id: i64,+ comment_id: &str,+ emoji: Option<&str>,+ ) -> Result<()> {+ let path = format!("{}/reaction", comment_path(viewer, post_id, comment_id)?);+ let Some(emoji) = emoji else {+ self.api().delete(&path).send().await?.error_for_status()?;+ return Ok(());+ };+ validate_contribution("reaction", emoji)?;+ let key = self+ .comment_post_key(viewer, post_space_id, post_id)+ .await?;+ let payload = DiscussionPayload {+ kind: "reaction".into(),+ post_id,+ comment_id: comment_id.into(),+ author_space_id: viewer.into(),+ reply_to_id: String::new(),+ text: emoji.into(),+ };+ self.api()+ .put(&path)+ .json(&serde_json::json!({"cipher":encrypt_contribution(&key, &payload)?}))+ .send()+ .await?+ .error_for_status()?;+ Ok(())+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::client::test_support::test_account_ctx;+ use crate::crypto::generate_key;+ use mockito::Matcher;++ #[tokio::test]+ async fn unsafe_comment_ids_never_send_requests() {+ let mut server = mockito::Server::new_async().await;+ let ctx = test_account_ctx(&server.url());+ let requests = server+ .mock("DELETE", Matcher::Any)+ .expect(0)+ .create_async()+ .await;+ let reads = server+ .mock("GET", Matcher::Any)+ .expect(0)+ .create_async()+ .await;+ let creates = server+ .mock("POST", Matcher::Any)+ .expect(0)+ .create_async()+ .await;+ let updates = server+ .mock("PUT", Matcher::Any)+ .expect(0)+ .create_async()+ .await;+ for id in [+ "../../../posts/42",+ r"..\..\..\posts\42",+ ".",+ "..",+ "",+ "%2e%2e%2fposts%2f42",+ "%252e%252e%252fposts%252f42",+ "comment/child",+ "comment?query=1",+ "comment#fragment",+ " comment",+ "comment ",+ "comment\n",+ "comment\0",+ "cรถmment",+ &"a".repeat(65),+ ] {+ assert!(+ matches!(+ ctx.delete_comment("owner", 42, id).await,+ Err(Error::InvalidInput(_))+ ),+ "{id}"+ );+ assert!(+ matches!(+ ctx.remove_comment_reaction("owner", 42, id, "actor").await,+ Err(Error::InvalidInput(_))+ ),+ "{id}"+ );+ for emoji in [None, Some("โค๏ธ")] {+ assert!(+ matches!(+ ctx.set_comment_reaction("owner", "owner", 42, id, emoji)+ .await,+ Err(Error::InvalidInput(_))+ ),+ "{id}"+ );+ }+ assert!(+ matches!(+ ctx.create_comment("owner", "owner", 42, id, None, "Hello")+ .await,+ Err(Error::InvalidInput(_))+ ),+ "{id}"+ );+ if !id.is_empty() {+ assert!(+ matches!(+ ctx.create_comment("owner", "owner", 42, "comment-1", Some(id), "Hello")+ .await,+ Err(Error::InvalidInput(_))+ ),+ "{id}"+ );+ }+ }+ requests.assert_async().await;+ reads.assert_async().await;+ creates.assert_async().await;+ updates.assert_async().await;+ }++ #[tokio::test]+ async fn comment_deletion_and_reaction_removal_use_only_comment_routes() {+ let mut server = mockito::Server::new_async().await;+ let ctx = test_account_ctx(&server.url());+ let post_delete = server+ .mock("DELETE", "/spaces/space_owner_main/posts/42")+ .expect(0)+ .create_async()+ .await;+ for id in [+ "5249f283-aaf2-4e6d-96c0-091f04b72f90",+ "comment-y",+ "wcomment_123",+ &"a".repeat(64),+ ] {+ let path = format!("/spaces/space_owner_main/discussions/42/comments/{id}");+ let delete = server+ .mock("DELETE", path.as_str())+ .match_header("x-space-session-token", "space-session-token")+ .with_status(200)+ .create_async()+ .await;+ ctx.delete_comment("space_owner_main", 42, id)+ .await+ .unwrap();+ delete.assert_async().await;+ let reaction_path = format!("{path}/reaction");+ let remove_own = server+ .mock("DELETE", reaction_path.as_str())+ .with_status(200)+ .create_async()+ .await;+ ctx.set_comment_reaction("space_owner_main", "space_owner_main", 42, id, None)+ .await+ .unwrap();+ remove_own.assert_async().await;+ let remove_other = server+ .mock("DELETE", reaction_path.as_str())+ .match_query(Matcher::UrlEncoded(+ "actorSpaceId".into(),+ "other?actor#id".into(),+ ))+ .with_status(200)+ .create_async()+ .await;+ ctx.remove_comment_reaction("space_owner_main", 42, id, "other?actor#id")+ .await+ .unwrap();+ remove_other.assert_async().await;+ }+ post_delete.assert_async().await;+ }++ #[tokio::test]+ async fn comment_paths_encode_space_id_segments() {+ let mut server = mockito::Server::new_async().await;+ let ctx = test_account_ctx(&server.url());+ let delete = server+ .mock(+ "DELETE",+ "/spaces/owner%2Fother%3Fquery%23fragment/discussions/42/comments/comment-1",+ )+ .with_status(200)+ .create_async()+ .await;+ ctx.delete_comment("owner/other?query#fragment", 42, "comment-1")+ .await+ .unwrap();+ delete.assert_async().await;+ }++ #[test]+ fn contributions_use_the_post_key_without_unlocking_other_content() {+ let post_key = generate_key();+ let other_post_key = generate_key();+ let profile_key = generate_key();+ let payload = DiscussionPayload {+ kind: "comment".into(),+ post_id: 42,+ comment_id: "comment-y".into(),+ author_space_id: "y".into(),+ reply_to_id: String::new(),+ text: "Hello Z".into(),+ };+ let cipher = encrypt_contribution(&post_key, &payload).unwrap();+ assert_eq!(+ decrypt_contribution(&post_key, &cipher, &payload).unwrap(),+ "Hello Z"+ );+ assert!(decrypt_contribution(&other_post_key, &cipher, &payload).is_err());+ assert!(decrypt_contribution(&profile_key, &cipher, &payload).is_err());+ let private_profile = encrypt_secretbox_payload(&profile_key, b"private profile").unwrap();+ assert!(decrypt_secretbox_payload(&post_key, &private_profile).is_err());+ }++ #[test]+ fn encrypted_contributions_bind_post_author_target_and_kind() {+ let key = generate_key();+ let mut payload = DiscussionPayload {+ kind: "reaction".into(),+ post_id: 42,+ comment_id: "reply-z".into(),+ author_space_id: "y".into(),+ reply_to_id: String::new(),+ text: "โค๏ธ".into(),+ };+ let cipher = encrypt_contribution(&key, &payload).unwrap();+ assert_eq!(decrypt_contribution(&key, &cipher, &payload).unwrap(), "โค๏ธ");+ payload.post_id = 43;+ assert!(decrypt_contribution(&key, &cipher, &payload).is_err());+ payload.post_id = 42;+ payload.author_space_id = "z".into();+ assert!(decrypt_contribution(&key, &cipher, &payload).is_err());+ payload.author_space_id = "y".into();+ payload.comment_id = "other".into();+ assert!(decrypt_contribution(&key, &cipher, &payload).is_err());+ payload.comment_id = "reply-z".into();+ payload.reply_to_id = "another".into();+ assert!(decrypt_contribution(&key, &cipher, &payload).is_err());+ payload.reply_to_id.clear();+ payload.kind = "comment".into();+ assert!(decrypt_contribution(&key, &cipher, &payload).is_err());+ assert!(validate_contribution("reaction", "hello").is_err());+ assert!(validate_contribution("comment", " ").is_err());+ }+}diff --git a/rust/crates/space/src/client/mod.rs b/rust/crates/space/src/client/mod.rsindex 3fd3108310..737b10b1c1 100644--- a/rust/crates/space/src/client/mod.rs+++ b/rust/crates/space/src/client/mod.rs@@ -1,4 +1,5 @@mod assets;+mod comments;mod entity_keys;mod friends;mod keys;diff --git a/rust/crates/space/src/client/notifications.rs b/rust/crates/space/src/client/notifications.rsindex 0d862a79b8..1341529c15 100644--- a/rust/crates/space/src/client/notifications.rs+++ b/rust/crates/space/src/client/notifications.rs@@ -51,6 +51,10 @@ impl AccountSpaceCtx {}items.push(Notification {notification_id: item.notification_id,+ post_space_id: item.post_space_id,+ post_owner_slug: item.post_owner_slug,+ comment_id: item.comment_id,+ reply_to_id: item.reply_to_id,notification_ids: item.notification_ids,kind: item.kind,actors,@@ -120,6 +124,33 @@ mod tests {page.assert_async().await;}+ #[tokio::test]+ async fn comment_notifications_preserve_post_owner_and_exact_reply() {+ let mut server = mockito::Server::new_async().await;+ let ctx = test_account_ctx(&server.url());+ let page = server.mock("GET", "/spaces/space_owner_main/notifications")+ .with_body(json!({"items": [{"notificationId":"reply-notification", "notificationIds":["reply-notification"], "kind":"comment_reply", "actors":[{"spaceId":"alice-space", "spaceSlug":"alice"}], "actorCount":1, "unread":true, "postId":42, "postSpaceId":"bob-space", "postOwnerSlug":"bob", "commentId":"reply-42", "replyToId":"parent-42", "createdAt":"2026-10-07T10:00:00Z"}]}).to_string())+ .create_async().await;+ let shares = server+ .mock("GET", "/spaces/space_owner_main/friends/shares")+ .with_body("[]")+ .create_async()+ .await;+ let notifications = ctx+ .list_notifications("space_owner_main", None, None)+ .await+ .unwrap();+ let reply = ¬ifications.items[0];+ assert_eq!(reply.post_space_id.as_deref(), Some("bob-space"));+ assert_eq!(reply.post_owner_slug.as_deref(), Some("bob"));+ assert_eq!(reply.comment_id.as_deref(), Some("reply-42"));+ assert_eq!(reply.reply_to_id.as_deref(), Some("parent-42"));+ assert_eq!(reply.actors[0].space_slug, "alice");+ assert!(reply.actors[0].profile.as_ref().unwrap().is_none());+ page.assert_async().await;+ shares.assert_async().await;+ }+#[tokio::test]async fn notification_feed_and_read_state_use_separate_endpoints() {let notification_ids: Vec<String> = (0..50).map(|i| format!("wnot_{i}")).collect();diff --git a/rust/crates/space/src/client/posts.rs b/rust/crates/space/src/client/posts.rsindex bf5fac9172..a1b9f6c614 100644--- a/rust/crates/space/src/client/posts.rs+++ b/rust/crates/space/src/client/posts.rs@@ -370,7 +370,7 @@ impl AccountSpaceCtx {Ok(HydratedKeys { owned, friends })}- async fn decrypt_post_key_fields(+ pub(super) async fn decrypt_post_key_fields(&self,space_id: &str,viewer_space_id: Option<&str>,@@ -594,6 +594,7 @@ pub(super) fn opened_post(content,created_at: post.created_at,viewer_liked: post.viewer_liked,+ comment_count: post.comment_count,}}@@ -624,6 +625,7 @@ mod tests {}],created_at: format!("2026-08-0{post_id}T00:00:00Z"),viewer_liked: false,+ comment_count: 0,}}diff --git a/rust/crates/space/src/client/reactions.rs b/rust/crates/space/src/client/reactions.rsindex 27c456a066..26e7e5ea3b 100644--- a/rust/crates/space/src/client/reactions.rs+++ b/rust/crates/space/src/client/reactions.rs@@ -97,7 +97,7 @@ fn unpack_reaction(message_id: &str, plaintext: &[u8]) -> Result<String> {Ok(payload.emoji)}-fn validate_emoji(emoji: &str) -> Result<()> {+pub(super) fn validate_emoji(emoji: &str) -> Result<()> {if emoji.is_empty() || emoji.len() > 64 || !is_emoji_sequence(emoji) {return Err(Error::InvalidInput("a single emoji is required".into()));}diff --git a/rust/crates/space/src/models.rs b/rust/crates/space/src/models.rsindex 55fb9c7365..ec2ae103a2 100644--- a/rust/crates/space/src/models.rs+++ b/rust/crates/space/src/models.rs@@ -67,6 +67,7 @@ pub struct Post {pub content: Result<PostContent>,pub created_at: String,pub viewer_liked: bool,+ pub comment_count: i64,}pub struct SpaceActor {@@ -221,6 +222,10 @@ pub struct MessagePage {}pub struct Notification {+ pub post_space_id: Option<String>,+ pub post_owner_slug: Option<String>,+ pub comment_id: Option<String>,+ pub reply_to_id: Option<String>,pub notification_id: String,pub notification_ids: Vec<String>,pub kind: String,@@ -306,6 +311,30 @@ pub struct HydratedKeys {pub friends: Vec<DecryptedFriendShare>,}+pub struct CommentReaction {+ pub actor: SpaceActor,+ pub emoji: String,+ pub is_own: bool,+}++pub struct Comment {+ pub comment_id: String,+ pub unread_notification_ids: Vec<String>,+ pub author: Option<SpaceActor>,+ pub parent_id: String,+ pub reply_to_id: String,+ pub text: Option<String>,+ pub deleted: bool,+ pub created_at: String,+ pub can_delete: bool,+ pub reactions: Vec<CommentReaction>,+}++pub struct CommentPage {+ pub items: Vec<Comment>,+ pub next_cursor: String,+}+#[cfg(test)]mod tests {use super::*;diff --git a/rust/crates/space/src/transport.rs b/rust/crates/space/src/transport.rsindex bb3b41f6f6..86ee71f638 100644--- a/rust/crates/space/src/transport.rs+++ b/rust/crates/space/src/transport.rs@@ -272,6 +272,8 @@ pub struct PostResponse {pub objects: Vec<PostObjectPayload>,pub created_at: String,pub viewer_liked: bool,+ #[serde(default)]+ pub comment_count: i64,}#[derive(Debug, Clone, Serialize, Deserialize)]@@ -696,6 +698,10 @@ pub struct SpaceLookupResponse {#[derive(Debug, Clone, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]pub struct NotificationResponse {+ pub post_space_id: Option<String>,+ pub post_owner_slug: Option<String>,+ pub comment_id: Option<String>,+ pub reply_to_id: Option<String>,pub notification_id: String,pub notification_ids: Vec<String>,pub kind: String,@@ -721,3 +727,33 @@ pub struct NotificationPageResponse {pub(crate) struct NotificationUnreadResponse {pub unread: bool,}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub(crate) struct CommentReactionResponse {+ pub actor: SpaceActorResponse,+ pub cipher: String,+ pub is_own: bool,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub(crate) struct CommentResponse {+ pub comment_id: String,+ #[serde(default)]+ pub unread_notification_ids: Vec<String>,+ pub author: Option<SpaceActorResponse>,+ pub parent_id: String,+ pub reply_to_id: String,+ pub cipher: String,+ pub created_at: String,+ pub can_delete: bool,+ pub reactions: Vec<CommentReactionResponse>,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub(crate) struct CommentPageResponse {+ pub items: Vec<CommentResponse>,+ pub next_cursor: String,+}diff --git a/rust/crates/space/tests/space.rs b/rust/crates/space/tests/space.rsindex 831dac703a..3971d175b6 100644--- a/rust/crates/space/tests/space.rs+++ b/rust/crates/space/tests/space.rs@@ -101,12 +101,14 @@ async fn request_and_confirm_friend(#[test]fn space_e2e() -> TestResult {- Museum::run_async(run)+ Museum::run(|museum| tokio::runtime::Runtime::new()?.block_on(run(museum)))}-async fn run(endpoint: String) -> TestResult {- space_bootstrap_posts_and_friend_share_suite(&endpoint).await;- space_unfriend_revokes_reciprocal_account_access_suite(&endpoint).await;+async fn run(museum: &Museum) -> TestResult {+ let endpoint = museum.endpoint();+ space_comments_suite(museum).await;+ space_bootstrap_posts_and_friend_share_suite(endpoint).await;+ space_unfriend_revokes_reciprocal_account_access_suite(endpoint).await;Ok(())}@@ -647,3 +649,641 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str)403,);}++async fn space_comments_suite(museum: &Museum) {+ let endpoint = museum.endpoint();+ let x_account = auth::create_account(endpoint, "comments-x").await;+ let y_account = auth::create_account(endpoint, "comments-y").await;+ let z_account = auth::create_account(endpoint, "comments-z").await;+ let outsider_account = auth::create_account(endpoint, "comments-outsider").await;+ let x = space::open_ctx(endpoint, &x_account).await;+ let y = space::open_ctx(endpoint, &y_account).await;+ let z = space::open_ctx(endpoint, &z_account).await;+ let outsider = space::open_ctx(endpoint, &outsider_account).await;+ let xs = x+ .create_space(+ &format!("cx_{}", x_account.user_id),+ &space::profile_payload("X private name", "X bio"),+ )+ .await+ .unwrap();+ let ys = y+ .create_space(+ &format!("cy_{}", y_account.user_id),+ &space::profile_payload("Y private name", "Y bio"),+ )+ .await+ .unwrap();+ let zs = z+ .create_space(+ &format!("cz_{}", z_account.user_id),+ &space::profile_payload("Z private name", "Z bio"),+ )+ .await+ .unwrap();+ let os = outsider+ .create_space(+ &format!("co_{}", outsider_account.user_id),+ &space::profile_payload("Outsider", "Private"),+ )+ .await+ .unwrap();+ z.update_space_profile_with_avatar(+ &zs.space_id,+ &space::profile_payload("Z private name", "Z bio"),+ TEST_WEBP_BYTES,+ )+ .await+ .unwrap();+ request_and_confirm_friend(&y, &ys.space_id, &x, &xs.space_id, &xs.space_slug).await;+ request_and_confirm_friend(&z, &zs.space_id, &x, &xs.space_id, &xs.space_slug).await;+ let post = x+ .create_photo_post(+ &xs.space_id,+ [PostPhotoInput {+ bytes: TEST_WEBP_BYTES.to_vec(),+ options: PostPhotoAssetOptions {+ width: Some(320),+ height: Some(240),+ media_type: Some("image/webp".into()),+ thumb_hash: None,+ },+ }]+ .into_iter(),+ Some("Post with comments"),+ )+ .await+ .unwrap();+ let id = post.post_id;+ space::assert_http_status(+ outsider+ .list_comments(&os.space_id, &xs.space_id, id, None)+ .await,+ 404,+ );+ y.create_comment(+ &ys.space_id,+ &xs.space_id,+ id,+ "comment-y",+ None,+ "Hello everyone",+ )+ .await+ .unwrap();+ z.create_comment(+ &zs.space_id,+ &xs.space_id,+ id,+ "reply-z",+ Some("comment-y"),+ "Hello Y",+ )+ .await+ .unwrap();+ y.create_comment(+ &ys.space_id,+ &xs.space_id,+ id,+ "reply-y",+ Some("reply-z"),+ "Hello Z",+ )+ .await+ .unwrap();+ z.set_comment_reaction(&zs.space_id, &xs.space_id, id, "comment-y", Some("โค๏ธ"))+ .await+ .unwrap();+ y.set_comment_reaction(&ys.space_id, &xs.space_id, id, "reply-z", Some("๐"))+ .await+ .unwrap();+ space::assert_http_status(+ y.remove_comment_reaction(&ys.space_id, id, "comment-y", &zs.space_id)+ .await,+ 403,+ );+ let raw: serde_json::Value = y+ .api()+ .get(&format!(+ "/spaces/{}/discussions/{id}/comments",+ ys.space_id+ ))+ .send()+ .await+ .unwrap()+ .error_for_status()+ .unwrap()+ .json()+ .await+ .unwrap();+ let asset = &post.content.as_ref().unwrap().photos[0].asset;+ let space_key = x+ .resolve_space_key_for_version_for_viewer(+ &xs.space_id,+ Some(&xs.space_id),+ Some(asset.key_version),+ )+ .await+ .unwrap()+ .unwrap();+ let post_key = ente_core::crypto::secretbox::decrypt_combined(+ &ente_core::b64::decode(&asset.encrypted_post_key).unwrap(),+ &ente_core::crypto::Key::try_from_slice(&space_key).unwrap(),+ )+ .unwrap();+ let post_key = ente_core::crypto::Key::try_from_slice(&post_key).unwrap();+ for (cipher, text) in [+ (&raw["items"][0]["cipher"], "Hello everyone"),+ (&raw["items"][0]["reactions"][0]["cipher"], "โค๏ธ"),+ ] {+ let bytes = ente_core::crypto::secretbox::decrypt_combined(+ &ente_core::b64::decode(cipher.as_str().unwrap()).unwrap(),+ &post_key,+ )+ .unwrap();+ let payload: serde_json::Value = serde_json::from_slice(&bytes).unwrap();+ assert_eq!(payload["text"], text);+ }+ let comments = y+ .list_comments(&ys.space_id, &xs.space_id, id, None)+ .await+ .unwrap();+ assert_eq!(comments.items.len(), 3);+ assert_eq!(comments.items[0].text.as_deref(), Some("Hello everyone"));+ assert_eq!(comments.items[1].text.as_deref(), Some("Hello Y"));+ assert_eq!(comments.items[2].parent_id, "comment-y");+ assert_eq!(comments.items[2].reply_to_id, "reply-z");+ assert!(+ comments.items[1]+ .author+ .as_ref()+ .unwrap()+ .profile+ .as_ref()+ .unwrap()+ .is_none()+ );+ assert!(comments.items[1].author.as_ref().unwrap().avatar.is_none());+ assert_eq!(+ comments.items[1].author.as_ref().unwrap().space_slug,+ zs.space_slug+ );+ assert!(!comments.items[1].can_delete);+ assert_eq!(comments.items[0].reactions[0].emoji, "โค๏ธ");+ assert!(+ comments.items[0].reactions[0]+ .actor+ .profile+ .as_ref()+ .unwrap()+ .is_none()+ );+ assert!(+ y.resolve_space_key_for_version_for_viewer(&zs.space_id, Some(&ys.space_id), None)+ .await+ .unwrap()+ .is_none()+ );+ x.remove_comment_reaction(&xs.space_id, id, "reply-z", &ys.space_id)+ .await+ .unwrap();+ assert!(+ y.list_comments(&ys.space_id, &xs.space_id, id, None)+ .await+ .unwrap()+ .items[1]+ .reactions+ .is_empty()+ );+ let owner_view = x+ .list_comments(&xs.space_id, &xs.space_id, id, None)+ .await+ .unwrap();+ assert!(+ owner_view.items[1]+ .author+ .as_ref()+ .unwrap()+ .profile+ .as_ref()+ .unwrap()+ .is_some()+ );+ assert!(+ owner_view.items[1]+ .author+ .as_ref()+ .unwrap()+ .avatar+ .is_some()+ );+ request_and_confirm_friend(&y, &ys.space_id, &z, &zs.space_id, &zs.space_slug).await;+ let friend_view = y+ .list_comments(&ys.space_id, &xs.space_id, id, None)+ .await+ .unwrap();+ assert!(+ friend_view.items[1]+ .author+ .as_ref()+ .unwrap()+ .profile+ .as_ref()+ .unwrap()+ .is_some()+ );+ assert!(+ friend_view.items[1]+ .author+ .as_ref()+ .unwrap()+ .avatar+ .is_some()+ );+ z.unfriend_by_space(&zs.space_id, &ys.space_id)+ .await+ .unwrap();+ let nonfriend_view = y+ .list_comments(&ys.space_id, &xs.space_id, id, None)+ .await+ .unwrap();+ assert!(+ nonfriend_view.items[1]+ .author+ .as_ref()+ .unwrap()+ .profile+ .as_ref()+ .unwrap()+ .is_none()+ );+ assert!(+ nonfriend_view.items[1]+ .author+ .as_ref()+ .unwrap()+ .avatar+ .is_none()+ );+ assert!(+ nonfriend_view.items[0].reactions[0]+ .actor+ .profile+ .as_ref()+ .unwrap()+ .is_none()+ );+ assert!(nonfriend_view.items[0].reactions[0].actor.avatar.is_none());+ space::assert_http_status(+ y.get_space_profile_raw(&zs.space_id, Some(&ys.space_id), None)+ .await,+ 403,+ );+ let notifications = y+ .list_notifications(&ys.space_id, None, None)+ .await+ .unwrap();+ let reply = notifications+ .items+ .iter()+ .find(|item| item.kind == "comment_reply")+ .unwrap();+ assert_eq!(reply.post_space_id.as_deref(), Some(xs.space_id.as_str()));+ assert!(reply.actors[0].profile.as_ref().unwrap().is_none());+ assert!(reply.actors[0].avatar.is_none());+ assert_eq!(reply.actors[0].space_slug, zs.space_slug);+ let object_key = &post.content.as_ref().unwrap().photos[0].asset.object_key;+ y.reply_to_post(+ &ys.space_id,+ &xs.space_id,+ id,+ "Only for X",+ Some(object_key),+ )+ .await+ .unwrap();+ assert_eq!(+ z.list_comments(&zs.space_id, &xs.space_id, id, None)+ .await+ .unwrap()+ .items+ .len(),+ 3+ );+ space::assert_http_status(y.delete_comment(&ys.space_id, id, "reply-z").await, 403);+ z.set_comment_reaction(&zs.space_id, &xs.space_id, id, "comment-y", None)+ .await+ .unwrap();+ assert!(+ y.list_comments(&ys.space_id, &xs.space_id, id, None)+ .await+ .unwrap()+ .items[0]+ .reactions+ .is_empty()+ );+ x.delete_comment(&xs.space_id, id, "reply-z").await.unwrap();+ let comments = y+ .list_comments(&ys.space_id, &xs.space_id, id, None)+ .await+ .unwrap();+ assert!(comments.items[1].deleted);+ assert!(comments.items[1].text.is_none());+ assert!(comments.items[1].reactions.is_empty());+ assert!(comments.items[2].deleted);+ assert!(comments.items[2].text.is_none());+ assert!(comments.items[2].reactions.is_empty());+ space::assert_http_status(+ y.create_comment(+ &ys.space_id,+ &xs.space_id,+ id,+ "deleted-reply",+ Some("reply-z"),+ "No",+ )+ .await,+ 404,+ );+ x.request_friend_by_username(&xs.space_id, &os.space_slug)+ .await+ .unwrap();+ y.create_comment(+ &ys.space_id,+ &xs.space_id,+ id,+ "while-pending",+ None,+ "During the request",+ )+ .await+ .unwrap();+ space::assert_http_status(+ outsider+ .list_comments(&os.space_id, &xs.space_id, id, None)+ .await,+ 404,+ );+ let pending = outsider.list_friend_requests(&os.space_id).await.unwrap();+ outsider+ .confirm_friend_request(&os.space_id, pending[0].request_id)+ .await+ .unwrap();+ assert_eq!(+ outsider+ .list_comments(&os.space_id, &xs.space_id, id, None)+ .await+ .unwrap()+ .items+ .last()+ .unwrap()+ .text+ .as_deref(),+ Some("During the request")+ );+ assert_eq!(+ outsider+ .list_comments(&os.space_id, &xs.space_id, id, None)+ .await+ .unwrap()+ .items[0]+ .text+ .as_deref(),+ Some("Hello everyone")+ );+ x.unfriend_by_space(&xs.space_id, &zs.space_id)+ .await+ .unwrap();+ space::assert_http_status(+ z.list_comments(&zs.space_id, &xs.space_id, id, None).await,+ 404,+ );+ space::assert_http_status(+ z.create_comment(+ &zs.space_id,+ &xs.space_id,+ id,+ "removed-z",+ None,+ "No access",+ )+ .await,+ 403,+ );+ space::assert_http_status(+ z.set_comment_reaction(&zs.space_id, &xs.space_id, id, "comment-y", Some("โค๏ธ"))+ .await,+ 403,+ );+ assert!(+ !z.list_notifications(&zs.space_id, None, None)+ .await+ .unwrap()+ .items+ .iter()+ .any(|item| item.kind.starts_with("comment"))+ );+ let revoked_write = z+ .api()+ .post(&format!(+ "/spaces/{}/discussions/{id}/comments",+ zs.space_id+ ))+ .json(&serde_json::json!({"commentId":"stale-access", "cipher":"YWJj"}))+ .send()+ .await+ .unwrap();+ assert_eq!(revoked_write.status(), 404);+ let revoked_reaction = z+ .api()+ .put(&format!(+ "/spaces/{}/discussions/{id}/comments/comment-y/reaction",+ zs.space_id+ ))+ .json(&serde_json::json!({"cipher":"YWJj"}))+ .send()+ .await+ .unwrap();+ assert_eq!(revoked_reaction.status(), 404);+ y.create_comment(+ &ys.space_id,+ &xs.space_id,+ id,+ "after-removal",+ None,+ "Still accessible",+ )+ .await+ .unwrap();+ assert_eq!(+ outsider+ .list_comments(&os.space_id, &xs.space_id, id, None)+ .await+ .unwrap()+ .items+ .last()+ .unwrap()+ .text+ .as_deref(),+ Some("Still accessible")+ );+ y.delete_comment(&ys.space_id, id, "comment-y")+ .await+ .unwrap();+ space::assert_http_status(+ outsider+ .create_comment(+ &os.space_id,+ &xs.space_id,+ id,+ "continued-thread",+ Some("reply-y"),+ "Cannot continue this thread",+ )+ .await,+ 404,+ );+ let deleted_thread = y+ .list_comments(&ys.space_id, &xs.space_id, id, None)+ .await+ .unwrap();+ for comment in deleted_thread+ .items+ .iter()+ .filter(|item| item.comment_id == "comment-y" || item.parent_id == "comment-y")+ {+ assert!(comment.deleted);+ assert!(comment.text.is_none());+ assert!(comment.reactions.is_empty());+ }+ space::assert_http_status(+ y.create_comment(+ &ys.space_id,+ &xs.space_id,+ id,+ "deleted-root-target",+ Some("comment-y"),+ "No",+ )+ .await,+ 404,+ );+ x.delete_post(&xs.space_id, id).await.unwrap();+ space::assert_http_status(+ y.list_comments(&ys.space_id, &xs.space_id, id, None).await,+ 404,+ );+ assert!(+ !y.list_notifications(&ys.space_id, None, None)+ .await+ .unwrap()+ .items+ .iter()+ .any(|item| item.kind.starts_with("comment"))+ );+ let post = x+ .create_photo_post(+ &xs.space_id,+ [PostPhotoInput {+ bytes: TEST_WEBP_BYTES.to_vec(),+ options: PostPhotoAssetOptions {+ width: Some(320),+ height: Some(240),+ media_type: Some("image/webp".into()),+ thumb_hash: None,+ },+ }]+ .into_iter(),+ Some("Discussion deletion"),+ )+ .await+ .unwrap();+ for (ctx, viewer, id, target) in [+ (&x, &xs.space_id, "delete-root-x", None),+ (&y, &ys.space_id, "delete-reply-y", Some("delete-root-x")),+ (&x, &xs.space_id, "delete-reply-x", Some("delete-reply-y")),+ (&y, &ys.space_id, "delete-root-y", None),+ (&x, &xs.space_id, "delete-child-x", Some("delete-root-y")),+ ] {+ ctx.create_comment(viewer, &xs.space_id, post.post_id, id, target, id)+ .await+ .unwrap();+ }+ y.set_comment_reaction(+ &ys.space_id,+ &xs.space_id,+ post.post_id,+ "delete-root-x",+ Some("โค๏ธ"),+ )+ .await+ .unwrap();+ let before = x+ .list_comments(&xs.space_id, &xs.space_id, post.post_id, None)+ .await+ .unwrap();+ assert!(+ before.items[1]+ .author+ .as_ref()+ .unwrap()+ .profile+ .as_ref()+ .unwrap()+ .is_some()+ );+ for sql in [+ format!(+ "UPDATE users SET encrypted_email = NULL WHERE user_id = {}",+ y_account.user_id+ ),+ format!("DELETE FROM spaces WHERE owner_id = {}", y_account.user_id),+ ] {+ museum.execute_sql(&sql).unwrap();+ let comments = x+ .list_comments(&xs.space_id, &xs.space_id, post.post_id, None)+ .await+ .unwrap();+ assert_eq!(comments.items.len(), 5);+ for item in &comments.items {+ if item.comment_id != "delete-root-x" {+ assert!(item.deleted);+ assert!(item.text.is_none());+ } else {+ assert!(!item.deleted);+ assert_eq!(item.text.as_deref(), Some(item.comment_id.as_str()));+ }+ if item.comment_id == "delete-reply-y" || item.comment_id == "delete-root-y" {+ assert!(item.author.is_none());+ }+ assert!(item.reactions.is_empty());+ }+ assert_eq!(comments.items[2].reply_to_id, "delete-reply-y");+ assert_eq!(comments.items[2].parent_id, "delete-root-x");+ assert_eq!(comments.items[4].reply_to_id, "delete-root-y");+ assert_eq!(comments.items[4].parent_id, "delete-root-y");+ }+ space::assert_http_status(+ x.create_comment(+ &xs.space_id,+ &xs.space_id,+ post.post_id,+ "after-account-deletion",+ Some("delete-child-x"),+ "Cannot continue the deleted thread",+ )+ .await,+ 404,+ );+ museum+ .execute_sql(&format!(+ "DELETE FROM space_posts WHERE post_id = {}",+ post.post_id+ ))+ .unwrap();+ space::assert_http_status(+ x.list_comments(&xs.space_id, &xs.space_id, post.post_id, None)+ .await,+ 404,+ );+}diff --git a/server/migrations/153_space_comments.down.sql b/server/migrations/153_space_comments.down.sqlnew file mode 100644index 0000000000..317805e087--- /dev/null+++ b/server/migrations/153_space_comments.down.sql@@ -0,0 +1,12 @@+DROP TRIGGER space_comment_author_deleted ON space_comments;+DROP FUNCTION space_comment_author_deleted();+DELETE FROM space_notifications WHERE comment_id IS NOT NULL;+ALTER TABLE space_notifications DROP CONSTRAINT chk_space_notifications_target;+ALTER TABLE space_notifications DROP COLUMN comment_id;+ALTER TABLE space_notifications ADD CONSTRAINT chk_space_notifications_target CHECK (+ (kind = 'post_like' AND post_like_id IS NOT NULL AND friend_request_id IS NULL AND poke_id IS NULL)+ OR (kind = 'friend_request' AND friend_request_id IS NOT NULL AND post_like_id IS NULL AND poke_id IS NULL)+ OR (kind = 'friend_accepted' AND post_like_id IS NULL AND friend_request_id IS NULL AND poke_id IS NULL)+ OR (kind = 'poke' AND poke_id IS NOT NULL AND post_like_id IS NULL AND friend_request_id IS NULL)+);+DROP TABLE space_comment_reactions, space_comments;diff --git a/server/migrations/153_space_comments.up.sql b/server/migrations/153_space_comments.up.sqlnew file mode 100644index 0000000000..ea3679daa1--- /dev/null+++ b/server/migrations/153_space_comments.up.sql@@ -0,0 +1,39 @@+CREATE TABLE space_comments (+ comment_id TEXT PRIMARY KEY,+ post_id BIGINT NOT NULL REFERENCES space_posts (post_id) ON DELETE CASCADE,+ author_space_id TEXT REFERENCES spaces (space_id) ON DELETE SET NULL,+ parent_id TEXT REFERENCES space_comments (comment_id) ON DELETE CASCADE,+ reply_to_id TEXT REFERENCES space_comments (comment_id),+ cipher BYTEA,+ created_at BIGINT NOT NULL DEFAULT now_utc_micro_seconds()+);+CREATE INDEX space_comments_post ON space_comments (post_id, created_at, comment_id);+CREATE TABLE space_comment_reactions (+ comment_id TEXT NOT NULL REFERENCES space_comments (comment_id) ON DELETE CASCADE,+ actor_space_id TEXT NOT NULL REFERENCES spaces (space_id) ON DELETE CASCADE,+ cipher BYTEA NOT NULL,+ PRIMARY KEY (comment_id, actor_space_id)+);++ALTER TABLE space_notifications ADD COLUMN comment_id TEXT REFERENCES space_comments (comment_id) ON DELETE CASCADE;+ALTER TABLE space_notifications DROP CONSTRAINT chk_space_notifications_target;+ALTER TABLE space_notifications ADD CONSTRAINT chk_space_notifications_target CHECK (+ (kind = 'post_like' AND post_like_id IS NOT NULL AND friend_request_id IS NULL AND poke_id IS NULL AND comment_id IS NULL)+ OR (kind = 'friend_request' AND friend_request_id IS NOT NULL AND post_like_id IS NULL AND poke_id IS NULL AND comment_id IS NULL)+ OR (kind = 'friend_accepted' AND post_like_id IS NULL AND friend_request_id IS NULL AND poke_id IS NULL AND comment_id IS NULL)+ OR (kind = 'poke' AND poke_id IS NOT NULL AND post_like_id IS NULL AND friend_request_id IS NULL AND comment_id IS NULL)+ OR (kind IN ('comment', 'comment_reply', 'comment_reaction') AND comment_id IS NOT NULL AND post_like_id IS NULL AND friend_request_id IS NULL AND poke_id IS NULL)+);+CREATE UNIQUE INDEX space_comment_notification ON space_notifications (recipient_space_id, actor_space_id, kind, comment_id) WHERE comment_id IS NOT NULL;++CREATE FUNCTION space_comment_author_deleted() RETURNS TRIGGER AS $$+BEGIN+ NEW.cipher = NULL;+ DELETE FROM space_comment_reactions WHERE comment_id = OLD.comment_id;+ DELETE FROM space_notifications WHERE comment_id = OLD.comment_id;+ RETURN NEW;+END;+$$ LANGUAGE plpgsql;++CREATE TRIGGER space_comment_author_deleted BEFORE UPDATE OF author_space_id ON space_comments+ FOR EACH ROW WHEN (NEW.author_space_id IS NULL) EXECUTE FUNCTION space_comment_author_deleted();diff --git a/server/space/api/comments.go b/server/space/api/comments.gonew file mode 100644index 0000000000..a5cd635350--- /dev/null+++ b/server/space/api/comments.go@@ -0,0 +1,56 @@+package api++import (+ "github.com/ente/museum/space/models"+ "github.com/ente/museum/space/repo"+ "github.com/gin-gonic/gin"+)++func (h *Handlers) ListComments(c *gin.Context, space *repo.SpaceRecord) {+ id, ok := positiveInt64Param(c, "postID")+ if !ok {+ return+ }+ response, err := h.Module.Comments.List(c, space, id, c.Query("cursor"))+ respondJSON(c, response, err)+}++func (h *Handlers) CreateComment(c *gin.Context, space *repo.SpaceRecord) {+ id, ok := positiveInt64Param(c, "postID")+ if !ok {+ return+ }+ var req models.CreateCommentRequest+ if !bindJSON(c, &req) {+ return+ }+ respondStatus(c, h.Module.Comments.Create(c, space, id, req))+}++func (h *Handlers) DeleteComment(c *gin.Context, space *repo.SpaceRecord) {+ id, ok := positiveInt64Param(c, "postID")+ if !ok {+ return+ }+ respondStatus(c, h.Module.Comments.Repo.Delete(c, space.SpaceID, id, c.Param("commentID")))+}++func (h *Handlers) SetCommentReaction(c *gin.Context, space *repo.SpaceRecord) {+ id, ok := positiveInt64Param(c, "postID")+ if !ok {+ return+ }+ var req models.SetCommentReactionRequest+ if !bindJSON(c, &req) {+ return+ }+ respondStatus(c, h.Module.Comments.React(c, space, id, c.Param("commentID"), &req, ""))+}++func (h *Handlers) DeleteCommentReaction(c *gin.Context, space *repo.SpaceRecord) {+ id, ok := positiveInt64Param(c, "postID")+ if !ok {+ return+ }+ respondStatus(c, h.Module.Comments.React(c, space, id, c.Param("commentID"), nil, c.Query("actorSpaceId")))+}diff --git a/server/space/api/comments_test.go b/server/space/api/comments_test.gonew file mode 100644index 0000000000..6bd099903c--- /dev/null+++ b/server/space/api/comments_test.go@@ -0,0 +1,51 @@+package api++import (+ "bytes"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/ente/museum/space/controller"+ "github.com/ente/museum/space/models"+ "github.com/ente/museum/space/repo"+ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++func TestCommentAPIRejectsUnsafeIDsBeforeStorage(t *testing.T) {+ handlers := &Handlers{Module: &controller.Module{Comments: &controller.CommentsController{}}}+ router := gin.New()+ router.POST("/discussions/:postID/comments", func(c *gin.Context) {+ handlers.CreateComment(c, &repo.SpaceRecord{SpaceID: "owner"})+ })+ for _, id := range []string{+ "../../../posts/42", `..\..\..\posts\42`, ".", "..",+ "%2e%2e%2fposts%2f42", "%252e%252e%252fposts%252f42",+ "comment/child", "comment?query=1", "comment#fragment",+ " comment", "comment ", "comment\n", "comment\x00", "cรถmment", strings.Repeat("a", 65),+ } {+ for _, field := range []string{"commentId", "replyToId"} {+ t.Run(field+"/"+id, func(t *testing.T) {+ body := map[string]string{"commentId": "comment-1", "cipher": "YWJj"}+ body[field] = id+ encoded, err := json.Marshal(body)+ require.NoError(t, err)+ request := httptest.NewRequest(http.MethodPost, "/discussions/42/comments", bytes.NewReader(encoded))+ request.Header.Set("Content-Type", "application/json")+ response := httptest.NewRecorder()+ router.ServeHTTP(response, request)+ require.Equal(t, http.StatusBadRequest, response.Code, response.Body.String())+ })+ }+ }+ t.Run("missing-comment-id", func(t *testing.T) {+ body, err := json.Marshal(models.CreateCommentRequest{Cipher: "YWJj"})+ require.NoError(t, err)+ response := httptest.NewRecorder()+ router.ServeHTTP(response, httptest.NewRequest(http.MethodPost, "/discussions/42/comments", bytes.NewReader(body)))+ require.Equal(t, http.StatusBadRequest, response.Code)+ })+}diff --git a/server/space/api/register.go b/server/space/api/register.goindex 4d4adb3cbd..1754c2d5cc 100644--- a/server/space/api/register.go+++ b/server/space/api/register.go@@ -20,6 +20,11 @@ func Register(privateAPI, publicAPI gin.IRouter, handlers *Handlers) {spaceAPI.GET("/notifications/unread", selected(handlers.GetNotificationUnread))spaceAPI.POST("/notifications/read", selected(handlers.ReadNotifications))spaceAPI.POST("/posts", selected(handlers.CreatePost))+ spaceAPI.GET("/discussions/:postID/comments", selected(handlers.ListComments))+ spaceAPI.POST("/discussions/:postID/comments", selected(handlers.CreateComment))+ spaceAPI.DELETE("/discussions/:postID/comments/:commentID", selected(handlers.DeleteComment))+ spaceAPI.PUT("/discussions/:postID/comments/:commentID/reaction", selected(handlers.SetCommentReaction))+ spaceAPI.DELETE("/discussions/:postID/comments/:commentID/reaction", selected(handlers.DeleteCommentReaction))spaceAPI.GET("/feed", selected(handlers.ListFeed))spaceAPI.POST("/posts/:postID/caption", selected(handlers.UpdatePostCaption))spaceAPI.PATCH("/posts/:postID/caption", selected(handlers.UpdatePostCaption))diff --git a/server/space/controller/comments.go b/server/space/controller/comments.gonew file mode 100644index 0000000000..b11441e8a8--- /dev/null+++ b/server/space/controller/comments.go@@ -0,0 +1,95 @@+package controller++import (+ "context"+ "regexp"++ "github.com/ente/museum/ente"+ "github.com/ente/museum/space/models"+ "github.com/ente/museum/space/repo"+)++var commentIDPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{1,64}$`)++type CommentsController struct {+ Repo *repo.CommentsRepository+ ActivityNotifier SpaceActivityNotifier+}++func discussionActor(actor repo.SpaceActorRecord, private bool) models.SpaceActorResponse {+ response := toActorResponse(actor, private)+ response.SpaceID = actor.SpaceID+ return response+}++func (c *CommentsController) List(ctx context.Context, space *repo.SpaceRecord, postID int64, cursor string) (*models.CommentPage, error) {+ records, next, err := c.Repo.List(ctx, space.SpaceID, postID, cursor)+ if err != nil {+ return nil, err+ }+ page := &models.CommentPage{Items: make([]models.CommentResponse, 0, len(records)), NextCursor: next}+ for _, record := range records {+ item := models.CommentResponse{+ CommentID: record.ID, ParentID: record.ParentID, ReplyToID: record.ReplyToID,+ Cipher: encodeSpaceField(record.Cipher), CreatedAt: formatMicros(record.CreatedAt),+ CanDelete: record.CanDelete,+ Reactions: make([]models.CommentReactionResponse, 0, len(record.Reactions)),+ UnreadNotificationIDs: record.UnreadNotificationIDs,+ }+ if record.Author.SpaceID != "" {+ author := discussionActor(record.Author, record.Private)+ item.Author = &author+ }+ for _, reaction := range record.Reactions {+ item.Reactions = append(item.Reactions, models.CommentReactionResponse{+ Actor: discussionActor(reaction.Actor, reaction.Private), Cipher: encodeSpaceField(reaction.Cipher), IsOwn: reaction.Actor.SpaceID == space.SpaceID,+ })+ }+ page.Items = append(page.Items, item)+ }+ return page, nil+}++func (c *CommentsController) Create(ctx context.Context, space *repo.SpaceRecord, postID int64, req models.CreateCommentRequest) error {+ if !commentIDPattern.MatchString(req.CommentID) || (req.ReplyToID != "" && !commentIDPattern.MatchString(req.ReplyToID)) {+ return ente.NewBadRequestWithMessage("invalid comment ID")+ }+ cipher, err := decodeEncodedSpaceField("cipher", req.Cipher, 24*1024, 18*1024)+ if err != nil {+ return err+ }+ if err := c.Repo.Create(ctx, space.SpaceID, postID, req, cipher); err != nil {+ return err+ }+ c.notify(ctx, space, postID, req.CommentID, false)+ return nil+}++func (c *CommentsController) React(ctx context.Context, space *repo.SpaceRecord, postID int64, commentID string, req *models.SetCommentReactionRequest, targetActor string) error {+ if req == nil {+ _, err := c.Repo.React(ctx, space.SpaceID, postID, commentID, nil, targetActor)+ return err+ }+ cipher, err := decodeEncodedSpaceField("cipher", req.Cipher, 2048, 1536)+ if err != nil {+ return err+ }+ notify, err := c.Repo.React(ctx, space.SpaceID, postID, commentID, cipher, "")+ if err != nil {+ return err+ }+ if notify {+ c.notify(ctx, space, postID, commentID, true)+ }+ return nil+}++func (c *CommentsController) notify(ctx context.Context, actor *repo.SpaceRecord, postID int64, commentID string, reaction bool) {+ recipients, owner, err := c.Repo.NotificationRecipients(ctx, actor.SpaceID, postID, commentID, reaction)+ if err != nil {+ return+ }+ for _, recipient := range recipients {+ go c.ActivityNotifier.OnSpaceComment(spaceActivityActor(actor), recipient.UserID, spaceActivityActor(&owner), postID, commentID, recipient.Kind)+ }+}diff --git a/server/space/controller/comments_test.go b/server/space/controller/comments_test.gonew file mode 100644index 0000000000..cbd71eab5f--- /dev/null+++ b/server/space/controller/comments_test.go@@ -0,0 +1,217 @@+package controller++import (+ "encoding/base64"+ "strings"+ "testing"++ "github.com/ente/museum/space/models"+ "github.com/ente/museum/space/repo"+ "github.com/stretchr/testify/require"+)++func TestCommentIDFormatAcceptsGeneratedAndExistingSafeIDs(t *testing.T) {+ for _, id := range []string{"5249f283-aaf2-4e6d-96c0-091f04b72f90", "comment-y", "wcomment_123", "A0", strings.Repeat("a", 64)} {+ require.True(t, commentIDPattern.MatchString(id), id)+ }+}++func TestDiscussionCountsOnPostsAndFeed(t *testing.T) {+ posts, repos, ctx := setupPostsControllerTest(t)+ ownerID := insertSpaceControllerUser(t, repos, "[email protected]", "owner-public")+ owner, err := testCreateSpace(ctx, repos, ownerID, "owner_count", "root", "owner-public", "secret", "nonce", "profile")+ require.NoError(t, err)+ friendID := insertSpaceControllerUser(t, repos, "[email protected]", "friend-public")+ friend, err := testCreateSpace(ctx, repos, friendID, "friend_count", "root", "friend-public", "secret", "nonce", "profile")+ require.NoError(t, err)+ require.NoError(t, testAddFriend(ctx, repos, friendID, friend.SpaceID, owner.SpaceID, "owner-share", 1, "friend-share", 1))+ postID, err := testCreatePost(ctx, repos, ownerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ otherPostID, err := testCreatePost(ctx, repos, ownerID, owner.SpaceID, "other-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, repos.Comments.Create(ctx, owner.SpaceID, otherPostID, models.CreateCommentRequest{CommentID: "other"}, []byte("other")))+ assertCount := func(count int64) {+ t.Helper()+ post, err := repos.Posts.GetPost(ctx, postID, owner.SpaceID)+ require.NoError(t, err)+ response, err := posts.postResponse(ctx, post, true)+ require.NoError(t, err)+ require.Equal(t, count, response.CommentCount)+ feed, err := posts.ListFeed(ctx, owner, models.ListFeedRequest{})+ require.NoError(t, err)+ require.Len(t, feed.Items, 2)+ for _, item := range feed.Items {+ if item.PostID == postID {+ require.Equal(t, count, item.CommentCount)+ } else {+ require.EqualValues(t, 1, item.CommentCount)+ }+ }+ }+ assertCount(0)+ require.NoError(t, repos.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: "root"}, []byte("root")))+ require.NoError(t, repos.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "reply", ReplyToID: "root"}, []byte("reply")))+ assertCount(2)+ require.NoError(t, repos.Comments.Delete(ctx, owner.SpaceID, postID, "root"))+ assertCount(0)+ require.NoError(t, repos.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "remaining"}, []byte("remaining")))+ assertCount(1)+ _, err = repos.Comments.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, friendID)+ require.NoError(t, err)+ assertCount(0)+}++func TestDiscussionNotifiesPostOwnerAndPreviousParticipants(t *testing.T) {+ _, repos, ctx := setupPostsControllerTest(t)+ notifier := newRecordingSpaceActivityNotifier()+ comments := NewModule(repos, nil, notifier, nil).Comments+ spaces := make(map[string]*repo.SpaceRecord)+ for _, name := range []string{"owner", "alice", "bob", "observer"} {+ userID := insertSpaceControllerUser(t, repos, name+"[email protected]", name+"-public")+ space, err := testCreateSpace(ctx, repos, userID, name+"_discussion", "root", name+"-public", "secret", "nonce", "profile")+ require.NoError(t, err)+ spaces[name] = space+ if name != "owner" {+ require.NoError(t, testAddFriend(ctx, repos, userID, space.SpaceID, spaces["owner"].SpaceID, "owner-share", 1, "friend-share", 1))+ }+ }+ owner := spaces["owner"]+ postID, err := testCreatePost(ctx, repos, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ otherPostID, err := testCreatePost(ctx, repos, owner.OwnerID, owner.SpaceID, "other-post-key", nil, 1, nil)+ require.NoError(t, err)+ for _, test := range []struct {+ id string+ actor string+ postID int64+ replyTo string+ recipients map[string]string+ }{+ {"other-post", "observer", otherPostID, "", map[string]string{"owner": "comment"}},+ {"first", "alice", postID, "", map[string]string{"owner": "comment"}},+ {"repeat", "alice", postID, "", map[string]string{"owner": "comment"}},+ {"second", "bob", postID, "first", map[string]string{"owner": "comment", "alice": "comment_reply"}},+ {"new-comment", "alice", postID, "", map[string]string{"owner": "comment"}},+ {"owner-reply", "owner", postID, "first", map[string]string{"alice": "comment_reply", "bob": "comment"}},+ {"reply", "alice", postID, "second", map[string]string{"owner": "comment", "bob": "comment_reply"}},+ {"reply-to-owner", "bob", postID, "owner-reply", map[string]string{"owner": "comment_reply"}},+ {"after-friending", "alice", postID, "", map[string]string{"owner": "comment", "bob": "comment"}},+ {"after-unfriending", "alice", postID, "", map[string]string{"owner": "comment"}},+ {"after-removal", "owner", postID, "", map[string]string{"bob": "comment"}},+ {"after-deletion", "owner", postID, "", map[string]string{}},+ } {+ t.Run(test.id, func(t *testing.T) {+ if test.id == "after-friending" {+ require.NoError(t, testAddFriend(ctx, repos, spaces["alice"].OwnerID, spaces["alice"].SpaceID, spaces["bob"].SpaceID, "bob-share", 1, "alice-share", 1))+ }+ if test.id == "after-unfriending" {+ require.NoError(t, repos.Friends.DeleteFriendship(ctx, spaces["alice"].SpaceID, spaces["bob"].SpaceID))+ }+ if test.id == "after-removal" {+ require.NoError(t, repos.Friends.DeleteFriendship(ctx, owner.SpaceID, spaces["alice"].SpaceID))+ }+ if test.id == "after-deletion" {+ _, err := repos.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, spaces["bob"].OwnerID)+ require.NoError(t, err)+ }+ require.NoError(t, comments.Create(ctx, spaces[test.actor], test.postID, models.CreateCommentRequest{+ CommentID: test.id,+ ReplyToID: test.replyTo,+ Cipher: base64.StdEncoding.EncodeToString([]byte(test.id)),+ }))+ var expectedRecipients, notifiedRecipients []int64+ expectedKinds := make(map[int64]string)+ for name, kind := range test.recipients {+ expectedRecipients = append(expectedRecipients, spaces[name].OwnerID)+ expectedKinds[spaces[name].OwnerID] = kind+ }+ for range test.recipients {+ activity := requireSpaceActivity(t, notifier)+ require.Equal(t, spaces[test.actor].SpaceID, activity.actorSpaceID)+ require.Equal(t, spaceActivityActor(owner), activity.postOwner)+ require.Equal(t, test.postID, activity.postID)+ require.Equal(t, test.id, activity.commentID)+ require.Len(t, activity.recipientIDs, 1)+ require.Equal(t, expectedKinds[activity.recipientIDs[0]], activity.event)+ notifiedRecipients = append(notifiedRecipients, activity.recipientIDs...)+ }+ require.ElementsMatch(t, expectedRecipients, notifiedRecipients)+ requireNoSpaceActivity(t, notifier)+ for name, space := range spaces {+ items, _, err := repos.Notifications.List(ctx, space.SpaceID, "", 50)+ require.NoError(t, err)+ var kinds []string+ for _, item := range items {+ if item.CommentID == test.id {+ require.Equal(t, owner.SpaceID, item.PostSpaceID)+ require.Equal(t, owner.SpaceSlug, item.PostOwnerSlug)+ require.Equal(t, test.postID, item.PostID.Int64)+ kinds = append(kinds, item.Kind)+ }+ }+ if kind, ok := test.recipients[name]; ok {+ require.Equal(t, []string{kind}, kinds, name)+ } else {+ require.Empty(t, kinds, name)+ }+ }+ })+ }+}++func TestCommentReactionChangesDoNotSendAnotherPush(t *testing.T) {+ _, repos, ctx := setupPostsControllerTest(t)+ notifier := newRecordingSpaceActivityNotifier()+ comments := NewModule(repos, nil, notifier, nil).Comments+ ownerID := insertSpaceControllerUser(t, repos, "[email protected]", "owner-public")+ owner, err := testCreateSpace(ctx, repos, ownerID, "owner_reaction", "root", "owner-public", "secret", "nonce", "profile")+ require.NoError(t, err)+ friendID := insertSpaceControllerUser(t, repos, "[email protected]", "friend-public")+ friend, err := testCreateSpace(ctx, repos, friendID, "friend_reaction", "root", "friend-public", "secret", "nonce", "profile")+ require.NoError(t, err)+ require.NoError(t, testAddFriend(ctx, repos, friendID, friend.SpaceID, owner.SpaceID, "owner-share", 1, "friend-share", 1))+ postID, err := testCreatePost(ctx, repos, ownerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, repos.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "comment"}, []byte("comment")))+ var notificationID string+ for i, reaction := range []string{"heart", "laugh", "laugh"} {+ require.NoError(t, comments.React(ctx, owner, postID, "comment", &models.SetCommentReactionRequest{+ Cipher: base64.StdEncoding.EncodeToString([]byte(reaction)),+ }, ""))+ if i == 0 {+ activity := requireSpaceActivity(t, notifier)+ require.Equal(t, []int64{friendID}, activity.recipientIDs)+ require.Equal(t, "comment_reaction", activity.event)+ require.Equal(t, spaceActivityActor(owner), activity.postOwner)+ require.Equal(t, postID, activity.postID)+ }+ requireNoSpaceActivity(t, notifier)+ items, _, err := repos.Notifications.List(ctx, friend.SpaceID, "", 50)+ require.NoError(t, err)+ require.Len(t, items, 2)+ require.Equal(t, "comment_reaction", items[0].Kind)+ if i == 0 {+ notificationID = items[0].NotificationID+ }+ require.Equal(t, notificationID, items[0].NotificationID)+ require.Equal(t, i == 0, items[0].Unread)+ require.NoError(t, repos.Notifications.MarkRead(ctx, friend.SpaceID, []string{items[0].NotificationID}))+ var cipher []byte+ require.NoError(t, repos.Comments.DB.QueryRowContext(ctx, `SELECT cipher FROM space_comment_reactions WHERE comment_id = 'comment' AND actor_space_id = $1`, owner.SpaceID).Scan(&cipher))+ require.Equal(t, reaction, string(cipher))+ }+ require.NoError(t, comments.React(ctx, owner, postID, "comment", nil, ""))+ requireNoSpaceActivity(t, notifier)+ items, _, err := repos.Notifications.List(ctx, friend.SpaceID, "", 50)+ require.NoError(t, err)+ require.Len(t, items, 1)+ require.Equal(t, "friend_accepted", items[0].Kind)+ require.NoError(t, comments.React(ctx, owner, postID, "comment", &models.SetCommentReactionRequest{+ Cipher: base64.StdEncoding.EncodeToString([]byte("heart")),+ }, ""))+ require.Equal(t, []int64{friendID}, requireSpaceActivity(t, notifier).recipientIDs)+ require.NoError(t, comments.React(ctx, friend, postID, "comment", &models.SetCommentReactionRequest{+ Cipher: base64.StdEncoding.EncodeToString([]byte("self")),+ }, ""))+ requireNoSpaceActivity(t, notifier)+}diff --git a/server/space/controller/helpers.go b/server/space/controller/helpers.goindex cde848274b..b6b13f7981 100644--- a/server/space/controller/helpers.go+++ b/server/space/controller/helpers.go@@ -111,6 +111,7 @@ func toPostResponse(post *spacerepo.SpacePostRecord, assets []spacerepo.SpacePosKeyVersion: post.KeyVersion,CreatedAt: formatMicros(post.CreatedAt),ViewerLiked: post.ViewerLiked,+ CommentCount: post.CommentCount,}if len(assets) > 0 {resp.Objects = make([]models.PostObjectPayload, 0, len(assets))diff --git a/server/space/controller/module.go b/server/space/controller/module.goindex 4f875f534a..3169ff6063 100644--- a/server/space/controller/module.go+++ b/server/space/controller/module.go@@ -7,6 +7,7 @@ import ()type Module struct {+ Comments *CommentsControllerSpaces *SpacesControllerPosts *PostsControllerFriends *FriendsController@@ -44,6 +45,7 @@ func NewModule(assets := &AssetsController{AssetsRepo: repos.Assets, SpacesRepo: repos.Spaces, auth: authDeps}links := &LinksController{LinksRepo: repos.Links, SpacesRepo: repos.Spaces, FriendsRepo: repos.Friends, Posts: posts, Assets: assets}return &Module{+ Comments: &CommentsController{Repo: repos.Comments, ActivityNotifier: activityNotifier},Spaces: spaces,Posts: posts,Friends: &FriendsController{FriendsRepo: repos.Friends, SpacesRepo: repos.Spaces, ActivityNotifier: activityNotifier},diff --git a/server/space/controller/notification_feed.go b/server/space/controller/notification_feed.goindex 5d4fed9578..ea7eeac378 100644--- a/server/space/controller/notification_feed.go+++ b/server/space/controller/notification_feed.go@@ -21,6 +21,10 @@ func (c *NotificationsController) List(ctx context.Context, space *repo.SpaceRecfor _, record := range records {item := models.NotificationResponse{NotificationID: record.NotificationID,+ PostSpaceID: record.PostSpaceID,+ PostOwnerSlug: record.PostOwnerSlug,+ CommentID: record.CommentID,+ ReplyToID: record.ReplyToID,NotificationIDs: record.NotificationIDs,Kind: record.Kind,Actors: make([]models.SpaceActorResponse, 0, len(record.Actors)),diff --git a/server/space/controller/notifications.go b/server/space/controller/notifications.goindex 30b4c0cff0..1c092b4d5d 100644--- a/server/space/controller/notifications.go+++ b/server/space/controller/notifications.go@@ -55,6 +55,7 @@ func spaceActivityActor(space *repo.SpaceRecord) SpaceActivityActor {}type SpaceActivityNotifier interface {+ OnSpaceComment(actor SpaceActivityActor, recipientUserID int64, postOwner SpaceActivityActor, postID int64, commentID, kind string)OnSpacePostCreated(actor SpaceActivityActor, postID int64)OnSpacePostLiked(actor SpaceActivityActor, recipientUserID int64)OnSpacePostReplied(actor SpaceActivityActor, recipientUserID int64)@@ -415,3 +416,20 @@ func isPublicWebPushAddress(address net.IP) bool {}return true}++func (n *SpaceWebPushSender) OnSpaceComment(actor SpaceActivityActor, recipientUserID int64, postOwner SpaceActivityActor, postID int64, commentID, kind string) {+ post := "@" + postOwner.Slug + "'s post"+ if recipientUserID == postOwner.UserID {+ post = "your post"+ } else if actor.SpaceID == postOwner.SpaceID {+ post = "their post"+ }+ activity := "commented on " + post+ switch kind {+ case "comment_reply":+ activity = "replied to your comment"+ case "comment_reaction":+ activity = "reacted to your comment"+ }+ n.sendAccountActivity(actor, activity, "View comments", "comment", fmt.Sprintf("/app/posts/%s/%d?comments=1&comment=%s", url.PathEscape(postOwner.SpaceID), postID, url.QueryEscape(commentID)), recipientUserID)+}diff --git a/server/space/controller/notifications_test.go b/server/space/controller/notifications_test.goindex 2a0c088800..02035cc9b2 100644--- a/server/space/controller/notifications_test.go+++ b/server/space/controller/notifications_test.go@@ -27,6 +27,8 @@ type recordedSpaceActivity struct {actorSpaceID stringactorSlug stringpostID int64+ postOwner SpaceActivityActor+ commentID stringrecipientIDs []int64}@@ -417,7 +419,7 @@ func TestPublicPostPushCarriesOnlyOpaqueLocalRouteTarget(t *testing.T) {}, payload)}-func TestFriendPushNotificationDestinations(t *testing.T) {+func TestFriendAndDiscussionPushNotificationDestinations(t *testing.T) {_, repos, ctx := setupPostsControllerTest(t)recipientID := insertSpaceControllerUser(t, repos, "[email protected]", "recipient-public")sessionHash := []byte("friend-push-session")@@ -432,11 +434,40 @@ func TestFriendPushNotificationDestinations(t *testing.T) {return &http.Response{StatusCode: http.StatusCreated, Body: io.NopCloser(strings.NewReader(""))}, nil}sender := NewSpaceWebPushSender(repos.WebPush, newSpaceWebPushTestConfig(t))- actor := SpaceActivityActor{UserID: 1, SpaceID: "alice-space", Slug: "alice"}+ actor := SpaceActivityActor{UserID: recipientID + 1, SpaceID: "alice-space", Slug: "alice"}sender.OnSpaceFriendRequested(actor, recipientID)require.Equal(t, spaceWebPushPayload{Title: "Ente Space", Body: "@alice sent you a friend request", Action: "Review request", URL: "/app/notifications"}, payload)sender.OnSpaceFriendAdded(actor, recipientID)require.Equal(t, spaceWebPushPayload{Title: "Ente Space", Body: "@alice accepted your friend request", Action: "Say hi", URL: "/app/messages/alice-space"}, payload)+ recipientOwner := SpaceActivityActor{UserID: recipientID, SpaceID: "post-owner", Slug: "recipient"}+ otherOwner := SpaceActivityActor{UserID: recipientID + 2, SpaceID: "post-owner", Slug: "bob"}+ for _, test := range []struct {+ name string+ kind string+ postOwner SpaceActivityActor+ body string+ }{+ {"comment-on-your-post", "comment", recipientOwner, "@alice commented on your post"},+ {"comment-on-another-post", "comment", otherOwner, "@alice commented on @bob's post"},+ {"comment-on-own-post", "comment", actor, "@alice commented on their post"},+ {"reply-on-your-post", "comment_reply", recipientOwner, "@alice replied to your comment"},+ {"reply-on-another-post", "comment_reply", otherOwner, "@alice replied to your comment"},+ {"reply-on-own-post", "comment_reply", actor, "@alice replied to your comment"},+ {"reaction-on-your-post", "comment_reaction", recipientOwner, "@alice reacted to your comment"},+ {"reaction-on-another-post", "comment_reaction", otherOwner, "@alice reacted to your comment"},+ {"reaction-on-own-post", "comment_reaction", actor, "@alice reacted to your comment"},+ } {+ t.Run(test.name, func(t *testing.T) {+ payload = spaceWebPushPayload{}+ sender.OnSpaceComment(actor, recipientID, test.postOwner, 42, "comment/with space", test.kind)+ require.Equal(t, spaceWebPushPayload{+ Title: "Ente Space",+ Body: test.body,+ Action: "View comments",+ URL: "/app/posts/" + test.postOwner.SpaceID + "/42?comments=1&comment=comment%2Fwith+space",+ }, payload)+ })+ }}func TestSpaceWebPushSendRateAppliesOncePerActivity(t *testing.T) {@@ -468,3 +499,16 @@ func TestSpaceWebPushSendRateAppliesOncePerActivity(t *testing.T) {)require.Equal(t, len(subscriptions), len(sent))}++func (n *recordingSpaceActivityNotifier) OnSpaceComment(actor SpaceActivityActor, recipientUserID int64, postOwner SpaceActivityActor, postID int64, commentID, kind string) {+ n.events <- recordedSpaceActivity{+ event: kind,+ actorUserID: actor.UserID,+ actorSpaceID: actor.SpaceID,+ actorSlug: actor.Slug,+ postID: postID,+ postOwner: postOwner,+ commentID: commentID,+ recipientIDs: []int64{recipientUserID},+ }+}diff --git a/server/space/controller/test_helpers_test.go b/server/space/controller/test_helpers_test.goindex 41ace16bfe..71cb851c79 100644--- a/server/space/controller/test_helpers_test.go+++ b/server/space/controller/test_helpers_test.go@@ -28,6 +28,9 @@ func setupPostsControllerTest(t *testing.T) (*PostsController, *spacerepo.Moduletype noopSpaceActivityNotifier struct{}+func (noopSpaceActivityNotifier) OnSpaceComment(SpaceActivityActor, int64, SpaceActivityActor, int64, string, string) {+}+func (noopSpaceActivityNotifier) OnSpacePostCreated(SpaceActivityActor, int64) {}func (noopSpaceActivityNotifier) OnSpacePostLiked(SpaceActivityActor, int64) {}func (noopSpaceActivityNotifier) OnSpacePostReplied(SpaceActivityActor, int64) {}diff --git a/server/space/models/comments.go b/server/space/models/comments.gonew file mode 100644index 0000000000..5999235acc--- /dev/null+++ b/server/space/models/comments.go@@ -0,0 +1,34 @@+package models++type CreateCommentRequest struct {+ CommentID string `json:"commentId" binding:"required,max=64"`+ ReplyToID string `json:"replyToId" binding:"max=64"`+ Cipher string `json:"cipher" binding:"required"`+}++type SetCommentReactionRequest struct {+ Cipher string `json:"cipher" binding:"required"`+}++type CommentReactionResponse struct {+ Actor SpaceActorResponse `json:"actor"`+ Cipher string `json:"cipher"`+ IsOwn bool `json:"isOwn"`+}++type CommentResponse struct {+ CommentID string `json:"commentId"`+ Author *SpaceActorResponse `json:"author"`+ ParentID string `json:"parentId"`+ ReplyToID string `json:"replyToId"`+ Cipher string `json:"cipher"`+ CreatedAt string `json:"createdAt"`+ CanDelete bool `json:"canDelete"`+ Reactions []CommentReactionResponse `json:"reactions"`+ UnreadNotificationIDs []string `json:"unreadNotificationIds"`+}++type CommentPage struct {+ Items []CommentResponse `json:"items"`+ NextCursor string `json:"nextCursor"`+}diff --git a/server/space/models/models.go b/server/space/models/models.goindex bb060b3024..d1f1197733 100644--- a/server/space/models/models.go+++ b/server/space/models/models.go@@ -402,6 +402,7 @@ type PostResponse struct {Objects []PostObjectPayload `json:"objects,omitempty"`CreatedAt string `json:"createdAt"`ViewerLiked bool `json:"viewerLiked"`+ CommentCount int64 `json:"commentCount"`}type SpaceUnreadStatusResponse struct {@@ -439,6 +440,10 @@ type ReadNotificationsRequest struct {}type NotificationResponse struct {+ PostSpaceID string `json:"postSpaceId,omitempty"`+ PostOwnerSlug string `json:"postOwnerSlug,omitempty"`+ CommentID string `json:"commentId,omitempty"`+ ReplyToID string `json:"replyToId,omitempty"`NotificationID string `json:"notificationId"`NotificationIDs []string `json:"notificationIds"`Kind string `json:"kind"`diff --git a/server/space/repo/account_deletion.go b/server/space/repo/account_deletion.goindex 9edb1883fe..a19267f326 100644--- a/server/space/repo/account_deletion.go+++ b/server/space/repo/account_deletion.go@@ -208,6 +208,23 @@ func deleteSpaceRowsTx(ctx context.Context, tx *sql.Tx, userID int64, spaceIDs [return err}spaceIDArray := pq.Array(spaceIDs)+ if _, err := tx.ExecContext(ctx, `+ SELECT post_id FROM space_posts p+ WHERE EXISTS (SELECT 1 FROM space_comments c WHERE c.post_id = p.post_id AND c.author_space_id = ANY($1))+ ORDER BY post_id FOR UPDATE+ `, spaceIDArray); err != nil {+ return stacktrace.Propagate(err, "failed to lock space comment posts")+ }+ if _, err := tx.ExecContext(ctx, `+ WITH RECURSIVE branch AS (+ SELECT comment_id FROM space_comments WHERE author_space_id = ANY($1)+ UNION+ SELECT c.comment_id FROM space_comments c JOIN branch parent ON c.reply_to_id = parent.comment_id+ )+ DELETE FROM space_comments WHERE comment_id IN (SELECT comment_id FROM branch)+ `, spaceIDArray); err != nil {+ return stacktrace.Propagate(err, "failed to delete space comment branches")+ }if _, err := tx.ExecContext(ctx, `DELETE FROM space_messagesWHERE sender_space_id = ANY($1)diff --git a/server/space/repo/comments.go b/server/space/repo/comments.gonew file mode 100644index 0000000000..d2fae9b627--- /dev/null+++ b/server/space/repo/comments.go@@ -0,0 +1,348 @@+package repo++import (+ "context"+ "database/sql"+ "strconv"++ "github.com/ente/museum/ente"+ "github.com/ente/museum/ente/base"+ "github.com/ente/museum/space/models"+ "github.com/lib/pq"+)++type CommentsRepository struct{ DB *sql.DB }++type CommentRecord struct {+ ID string+ Author SpaceActorRecord+ Private bool+ ParentID string+ ReplyToID string+ Cipher []byte+ CreatedAt int64+ CanDelete bool+ Reactions []CommentReactionRecord+ UnreadNotificationIDs []string+}++type CommentReactionRecord struct {+ Actor SpaceActorRecord+ Private bool+ Cipher []byte+}++type CommentNotificationRecipient struct {+ UserID int64+ Kind string+}++const discussionAccessSQL = `(p.space_id = $2 OR EXISTS (SELECT 1 FROM space_friend_shares f WHERE f.space_id = p.space_id AND f.friend_space_id = $2))`++const commentVisibleSQL = `NOT EXISTS (+ WITH RECURSIVE ancestors AS (+ SELECT c.reply_to_id, c.author_space_id, c.cipher IS NOT NULL AS has_content+ UNION ALL+ SELECT parent.reply_to_id, parent.author_space_id, parent.cipher IS NOT NULL+ FROM space_comments parent JOIN ancestors child ON parent.comment_id = child.reply_to_id+ )+ SELECT 1 FROM ancestors a+ LEFT JOIN spaces author ON author.space_id = a.author_space_id+ LEFT JOIN users account ON account.user_id = author.owner_id+ WHERE NOT a.has_content OR account.encrypted_email IS NULL+)`++func discussionPostTx(ctx context.Context, tx *sql.Tx, viewer string, postID int64, forUpdate bool) (string, error) {+ locking := "FOR SHARE OF s, p"+ if forUpdate {+ locking = "FOR SHARE OF s FOR UPDATE OF p"+ }+ var owner string+ err := tx.QueryRowContext(ctx, `SELECT s.space_id FROM space_posts p+ JOIN spaces s ON s.space_id = p.space_id WHERE p.post_id = $1 AND NOT p.is_deleted `+locking, postID).Scan(&owner)+ if err != nil {+ return "", err+ }+ if owner != viewer {+ var friend string+ if err := tx.QueryRowContext(ctx, `SELECT friend_space_id FROM space_friend_shares+ WHERE space_id = $1 AND friend_space_id = $2 FOR SHARE`, owner, viewer).Scan(&friend); err != nil {+ return "", err+ }+ }+ var allowed bool+ err = tx.QueryRowContext(ctx, `SELECT EXISTS (SELECT 1 FROM space_posts p JOIN spaces s ON s.space_id = p.space_id+ JOIN users u ON u.user_id = s.owner_id AND u.encrypted_email IS NOT NULL+ WHERE p.post_id = $1 AND NOT p.is_deleted AND `+discussionAccessSQL+`+ AND EXISTS (SELECT 1 FROM spaces viewer JOIN users viewer_owner ON viewer_owner.user_id = viewer.owner_id+ WHERE viewer.space_id = $2 AND viewer_owner.encrypted_email IS NOT NULL))`, postID, viewer).Scan(&allowed)+ if err != nil {+ return "", err+ }+ if !allowed {+ return "", sql.ErrNoRows+ }+ return owner, nil+}++func (r *CommentsRepository) List(ctx context.Context, viewer string, postID int64, cursor string) ([]CommentRecord, string, error) {+ tx, err := r.DB.BeginTx(ctx, nil)+ if err != nil {+ return nil, "", err+ }+ defer tx.Rollback()+ owner, err := discussionPostTx(ctx, tx, viewer, postID, false)+ if err != nil {+ return nil, "", err+ }+ createdAt, id, _ := parseMessageCursor(cursor)+ rows, err := tx.QueryContext(ctx, `SELECT c.comment_id, COALESCE(c.parent_id, ''), COALESCE(c.reply_to_id, ''),+ CASE WHEN `+commentVisibleSQL+` THEN c.cipher END, c.created_at,+ (COALESCE(actor.space_id = $2, FALSE) OR EXISTS (SELECT 1 FROM space_friend_shares f WHERE f.space_id = actor.space_id AND f.friend_space_id = $2)),+ COALESCE(actor.space_id, ''), COALESCE(actor.space_slug, ''), actor.public_key, COALESCE(actor.current_version, 0), actor.encrypted_profile,+ avatar.object_id, avatar.key_version, avatar.size, COALESCE(actor.updated_at, 0)+ FROM space_comments c LEFT JOIN spaces actor ON actor.space_id = c.author_space_id+ AND EXISTS (SELECT 1 FROM users u WHERE u.user_id = actor.owner_id AND u.encrypted_email IS NOT NULL) `+spaceActorAvatarJoin("actor", "avatar")+`+ WHERE c.post_id = $1 AND (c.created_at, c.comment_id) > ($3, $4) ORDER BY c.created_at, c.comment_id LIMIT 101`, postID, viewer, createdAt, id)+ if err != nil {+ return nil, "", err+ }+ items := make([]CommentRecord, 0)+ for rows.Next() {+ var item CommentRecord+ dest := []any{&item.ID, &item.ParentID, &item.ReplyToID, &item.Cipher, &item.CreatedAt, &item.Private}+ if err := rows.Scan(append(dest, spaceActorScanDest(&item.Author)...)...); err != nil {+ rows.Close()+ return nil, "", err+ }+ item.CanDelete = len(item.Cipher) > 0 && (item.Author.SpaceID == viewer || owner == viewer)+ item.Reactions = make([]CommentReactionRecord, 0)+ item.UnreadNotificationIDs = make([]string, 0)+ items = append(items, item)+ }+ err = rows.Err()+ rows.Close()+ if err != nil {+ return nil, "", err+ }+ next := ""+ if len(items) > 100 {+ items = items[:100]+ last := items[99]+ next = strconv.FormatInt(last.CreatedAt, 10) + ":" + last.ID+ }+ commentIDs := make([]string, 0, len(items))+ commentsByID := make(map[string]*CommentRecord, len(items))+ for i := range items {+ if len(items[i].Cipher) > 0 {+ commentIDs = append(commentIDs, items[i].ID)+ commentsByID[items[i].ID] = &items[i]+ }+ }+ rows, err = tx.QueryContext(ctx, `SELECT r.comment_id, r.cipher,+ (actor.space_id = $2 OR EXISTS (SELECT 1 FROM space_friend_shares f WHERE f.space_id = actor.space_id AND f.friend_space_id = $2)), `+spaceActorSelectColumns("actor", "avatar", "actor")+`+ FROM space_comment_reactions r JOIN spaces actor ON actor.space_id = r.actor_space_id+ JOIN users u ON u.user_id = actor.owner_id AND u.encrypted_email IS NOT NULL `+spaceActorAvatarJoin("actor", "avatar")+`+ WHERE r.comment_id = ANY($1) ORDER BY r.comment_id, r.actor_space_id`, pq.Array(commentIDs), viewer)+ if err != nil {+ return nil, "", err+ }+ defer rows.Close()+ for rows.Next() {+ var commentID string+ var reaction CommentReactionRecord+ dest := []any{&commentID, &reaction.Cipher, &reaction.Private}+ if err := rows.Scan(append(dest, spaceActorScanDest(&reaction.Actor)...)...); err != nil {+ return nil, "", err+ }+ comment := commentsByID[commentID]+ comment.Reactions = append(comment.Reactions, reaction)+ }+ if err := rows.Err(); err != nil {+ return nil, "", err+ }+ rows.Close()+ rows, err = tx.QueryContext(ctx, `SELECT n.comment_id, n.notification_id `+notificationSourcesSQL+`+ WHERE n.recipient_space_id = $1 AND n.comment_id = ANY($2) AND n.read_at IS NULL AND `+notificationVisibleSQL, viewer, pq.Array(commentIDs))+ if err != nil {+ return nil, "", err+ }+ defer rows.Close()+ for rows.Next() {+ var commentID, notificationID string+ if err := rows.Scan(&commentID, ¬ificationID); err != nil {+ return nil, "", err+ }+ comment := commentsByID[commentID]+ comment.UnreadNotificationIDs = append(comment.UnreadNotificationIDs, notificationID)+ }+ if err := rows.Err(); err != nil {+ return nil, "", err+ }+ return items, next, tx.Commit()+}++func (r *CommentsRepository) Create(ctx context.Context, viewer string, postID int64, req models.CreateCommentRequest, cipher []byte) error {+ tx, err := r.DB.BeginTx(ctx, nil)+ if err != nil {+ return err+ }+ defer tx.Rollback()+ owner, err := discussionPostTx(ctx, tx, viewer, postID, true)+ if err != nil {+ return err+ }+ var parent, replyRecipient string+ if req.ReplyToID != "" {+ if err := tx.QueryRowContext(ctx, `SELECT COALESCE(c.parent_id, c.comment_id), c.author_space_id FROM space_comments c+ WHERE c.comment_id = $1 AND c.post_id = $2 AND `+commentVisibleSQL, req.ReplyToID, postID).Scan(&parent, &replyRecipient); err != nil {+ return err+ }+ }+ res, err := tx.ExecContext(ctx, `INSERT INTO space_comments (comment_id, post_id, author_space_id, parent_id, reply_to_id, cipher)+ VALUES ($1, $2, $3, NULLIF($4, ''), NULLIF($5, ''), $6) ON CONFLICT (comment_id) DO NOTHING`, req.CommentID, postID, viewer, parent, req.ReplyToID, cipher)+ if err != nil {+ return err+ }+ count, err := res.RowsAffected()+ if err != nil {+ return err+ }+ if count == 0 {+ return ente.NewConflictError("discussion changed; refresh and retry")+ }+ var recipients pq.StringArray+ if err := tx.QueryRowContext(ctx, `SELECT ARRAY(+ SELECT participant.space_id FROM (+ SELECT $1::text AS space_id+ UNION+ SELECT c.author_space_id FROM space_comments c WHERE c.post_id = $2 AND `+commentVisibleSQL+`+ ) participant+ JOIN spaces s ON s.space_id = participant.space_id+ JOIN users u ON u.user_id = s.owner_id AND u.encrypted_email IS NOT NULL+ WHERE participant.space_id <> $3+ )`, owner, postID, viewer).Scan(&recipients); err != nil {+ return err+ }+ for _, recipient := range recipients {+ kind := "comment"+ if recipient == replyRecipient {+ kind = "comment_reply"+ }+ if _, err := commentNotificationTx(ctx, tx, owner, viewer, recipient, req.CommentID, kind); err != nil {+ return err+ }+ }+ return tx.Commit()+}++func commentNotificationTx(ctx context.Context, tx *sql.Tx, owner, actor, recipient, commentID, kind string) (bool, error) {+ res, err := tx.ExecContext(ctx, `INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, comment_id)+ SELECT $1, $2, $3, $4, $5 WHERE $2 <> $3 AND ($2 = $6 OR EXISTS (SELECT 1 FROM space_friend_shares WHERE space_id = $6 AND friend_space_id = $2))+ AND ($4 <> 'comment' OR $2 = $6 OR EXISTS (SELECT 1 FROM space_friend_shares WHERE space_id = $2 AND friend_space_id = $3))+ ON CONFLICT DO NOTHING`, base.MustNewID("wnot"), recipient, actor, kind, commentID, owner)+ if err != nil {+ return false, err+ }+ count, err := res.RowsAffected()+ return count > 0, err+}++func (r *CommentsRepository) Delete(ctx context.Context, viewer string, postID int64, commentID string) error {+ tx, err := r.DB.BeginTx(ctx, nil)+ if err != nil {+ return err+ }+ defer tx.Rollback()+ owner, err := discussionPostTx(ctx, tx, viewer, postID, true)+ if err != nil {+ return err+ }+ var deletedIDs pq.StringArray+ err = tx.QueryRowContext(ctx, `WITH RECURSIVE branch AS (+ SELECT comment_id FROM space_comments WHERE comment_id = $1 AND post_id = $2+ AND (author_space_id = $3 OR $3 = $4)+ UNION ALL+ SELECT c.comment_id FROM space_comments c JOIN branch parent ON c.reply_to_id = parent.comment_id+ WHERE c.post_id = $2+ ), removed AS (+ UPDATE space_comments c SET cipher = NULL FROM branch+ WHERE c.comment_id = branch.comment_id RETURNING c.comment_id+ ) SELECT ARRAY(SELECT comment_id FROM removed)`, commentID, postID, viewer, owner).Scan(&deletedIDs)+ if err != nil {+ return err+ }+ if len(deletedIDs) == 0 {+ return ente.ErrPermissionDenied+ }+ if _, err := tx.ExecContext(ctx, `DELETE FROM space_comment_reactions WHERE comment_id = ANY($1)`, deletedIDs); err != nil {+ return err+ }+ if _, err := tx.ExecContext(ctx, `DELETE FROM space_notifications WHERE comment_id = ANY($1)`, deletedIDs); err != nil {+ return err+ }+ return tx.Commit()+}++func (r *CommentsRepository) React(ctx context.Context, viewer string, postID int64, commentID string, cipher []byte, targetActor string) (bool, error) {+ tx, err := r.DB.BeginTx(ctx, nil)+ if err != nil {+ return false, err+ }+ defer tx.Rollback()+ owner, err := discussionPostTx(ctx, tx, viewer, postID, true)+ if err != nil {+ return false, err+ }+ var author string+ if err := tx.QueryRowContext(ctx, `SELECT c.author_space_id FROM space_comments c+ WHERE c.comment_id = $1 AND c.post_id = $2 AND `+commentVisibleSQL, commentID, postID).Scan(&author); err != nil {+ return false, err+ }+ var notify bool+ if len(cipher) == 0 {+ if targetActor == "" {+ targetActor = viewer+ }+ if targetActor != viewer && viewer != owner {+ return false, ente.ErrPermissionDenied+ }+ if _, err := tx.ExecContext(ctx, `DELETE FROM space_comment_reactions WHERE comment_id = $1 AND actor_space_id = $2`, commentID, targetActor); err != nil {+ return false, err+ }+ if _, err := tx.ExecContext(ctx, `DELETE FROM space_notifications WHERE comment_id = $1 AND actor_space_id = $2 AND kind = 'comment_reaction'`, commentID, targetActor); err != nil {+ return false, err+ }+ } else {+ if _, err := tx.ExecContext(ctx, `INSERT INTO space_comment_reactions (comment_id, actor_space_id, cipher) VALUES ($1, $2, $3)+ ON CONFLICT (comment_id, actor_space_id) DO UPDATE SET cipher = EXCLUDED.cipher`, commentID, viewer, cipher); err != nil {+ return false, err+ }+ notify, err = commentNotificationTx(ctx, tx, owner, viewer, author, commentID, "comment_reaction")+ if err != nil {+ return false, err+ }+ }+ return notify, tx.Commit()+}++func (r *CommentsRepository) NotificationRecipients(ctx context.Context, actor string, postID int64, commentID string, reaction bool) ([]CommentNotificationRecipient, SpaceRecord, error) {+ var owner SpaceRecord+ rows, err := r.DB.QueryContext(ctx, `SELECT recipient.owner_id, n.kind, post_owner.owner_id, post_owner.space_id, post_owner.space_slug `+notificationSourcesSQL+`+ JOIN spaces recipient ON recipient.space_id = n.recipient_space_id+ JOIN spaces post_owner ON post_owner.space_id = p.space_id+ WHERE n.actor_space_id = $1 AND p.post_id = $2 AND n.comment_id = $3 AND (n.kind = 'comment_reaction') = $4 AND `+notificationVisibleSQL, actor, postID, commentID, reaction)+ if err != nil {+ return nil, owner, err+ }+ defer rows.Close()+ recipients := make([]CommentNotificationRecipient, 0)+ for rows.Next() {+ var recipient CommentNotificationRecipient+ if err := rows.Scan(&recipient.UserID, &recipient.Kind, &owner.OwnerID, &owner.SpaceID, &owner.SpaceSlug); err != nil {+ return nil, owner, err+ }+ recipients = append(recipients, recipient)+ }+ return recipients, owner, rows.Err()+}diff --git a/server/space/repo/comments_test.go b/server/space/repo/comments_test.gonew file mode 100644index 0000000000..ea80101715--- /dev/null+++ b/server/space/repo/comments_test.go@@ -0,0 +1,722 @@+package repo++import (+ "context"+ "database/sql"+ "testing"+ "time"++ "github.com/ente/museum/ente"+ "github.com/ente/museum/space/models"+ "github.com/stretchr/testify/require"+)++func TestDiscussionParentDeletionRemovesWholeThread(t *testing.T) {+ for _, deleteAsOwner := range []bool{false, true} {+ name := "author"+ if deleteAsOwner {+ name = "post-owner"+ }+ t.Run(name, func(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ for _, item := range []struct{ id, actor, replyTo string }{+ {"parent", friend.SpaceID, ""},+ {"reply", owner.SpaceID, "parent"},+ {"reply-to-reply", friend.SpaceID, "reply"},+ {"separate", owner.SpaceID, ""},+ } {+ require.NoError(t, module.Comments.Create(ctx, item.actor, postID, models.CreateCommentRequest{CommentID: item.id, ReplyToID: item.replyTo}, []byte(item.id)))+ }+ for _, id := range []string{"parent", "reply", "reply-to-reply", "separate"} {+ _, err := module.Comments.React(ctx, owner.SpaceID, postID, id, []byte("heart"), "")+ require.NoError(t, err)+ }+ actor := friend.SpaceID+ if deleteAsOwner {+ actor = owner.SpaceID+ }+ require.NoError(t, module.Comments.Delete(ctx, actor, postID, "parent"))+ items, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ for _, item := range items {+ if item.ID == "separate" {+ require.Equal(t, []byte("separate"), item.Cipher)+ require.Len(t, item.Reactions, 1)+ } else {+ require.Empty(t, item.Cipher)+ require.Empty(t, item.Reactions)+ require.Empty(t, item.UnreadNotificationIDs)+ }+ }+ require.EqualValues(t, 0, countSpaceRows(t, module, `SELECT count(*) FROM space_notifications WHERE comment_id IN ('parent', 'reply', 'reply-to-reply')`))+ require.EqualValues(t, 0, countSpaceRows(t, module, `SELECT count(*) FROM space_comment_reactions WHERE comment_id IN ('parent', 'reply', 'reply-to-reply')`))+ require.ErrorIs(t, module.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: "late-reply", ReplyToID: "reply"}, []byte("late")), sql.ErrNoRows)+ _, err = module.Comments.React(ctx, owner.SpaceID, postID, "reply", []byte("heart"), "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ })+ }+}++func TestDiscussionReplyDeletionRemovesDescendantsAndPreservesSiblings(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ for _, item := range []struct{ id, actor, replyTo string }{+ {"parent", owner.SpaceID, ""},+ {"reply", friend.SpaceID, "parent"},+ {"reply-to-reply", owner.SpaceID, "reply"},+ {"deep-reply", friend.SpaceID, "reply-to-reply"},+ {"sibling", friend.SpaceID, "parent"},+ {"sibling-child", owner.SpaceID, "sibling"},+ } {+ require.NoError(t, module.Comments.Create(ctx, item.actor, postID, models.CreateCommentRequest{CommentID: item.id, ReplyToID: item.replyTo}, []byte(item.id)))+ }+ for _, id := range []string{"reply", "reply-to-reply", "deep-reply", "sibling", "sibling-child"} {+ _, err = module.Comments.React(ctx, owner.SpaceID, postID, id, []byte("heart"), "")+ require.NoError(t, err)+ }+ require.ErrorIs(t, module.Comments.Delete(ctx, friend.SpaceID, postID, "parent"), ente.ErrPermissionDenied)+ require.NoError(t, module.Comments.Delete(ctx, friend.SpaceID, postID, "reply"))+ items, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ require.Len(t, items, 6)+ for _, item := range items {+ if item.ID == "reply" || item.ID == "reply-to-reply" || item.ID == "deep-reply" {+ require.Empty(t, item.Cipher)+ require.Empty(t, item.Reactions)+ require.Empty(t, item.UnreadNotificationIDs)+ } else {+ require.Equal(t, []byte(item.ID), item.Cipher)+ if item.ID != "parent" {+ require.Equal(t, "parent", item.ParentID)+ require.Len(t, item.Reactions, 1)+ }+ }+ }+ require.EqualValues(t, 0, countSpaceRows(t, module, `SELECT count(*) FROM space_notifications WHERE comment_id IN ('reply', 'reply-to-reply', 'deep-reply')`))+ require.EqualValues(t, 0, countSpaceRows(t, module, `SELECT count(*) FROM space_comment_reactions WHERE comment_id IN ('reply', 'reply-to-reply', 'deep-reply')`))+ require.Greater(t, countSpaceRows(t, module, `SELECT count(*) FROM space_notifications WHERE comment_id IN ('sibling', 'sibling-child')`), int64(0))+ post, err := module.Posts.GetPost(ctx, postID, owner.SpaceID)+ require.NoError(t, err)+ require.EqualValues(t, 3, post.CommentCount)+ require.ErrorIs(t, module.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "deleted-target", ReplyToID: "deep-reply"}, []byte("new")), sql.ErrNoRows)+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "new-reply", ReplyToID: "sibling-child"}, []byte("new")))+}++func TestDiscussionAudienceAndAccess(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ outsiderID := insertSpaceUser(t, module, "[email protected]", "outsider")+ outsider, err := testCreateSpace(ctx, module, outsiderID, "comment_outsider", "root", "public", "secret", "nonce", "private")+ require.NoError(t, err)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ _, _, err = module.Comments.List(ctx, outsider.SpaceID, postID, "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ require.ErrorIs(t, module.Comments.Create(ctx, outsider.SpaceID, postID, models.CreateCommentRequest{CommentID: "outsider"}, []byte("cipher")), sql.ErrNoRows)+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "root"}, []byte("cipher")))+ _, _, _, err = module.Friends.CreateFriendRequest(ctx, owner.OwnerID, owner.SpaceID, outsider.SpaceID, []byte("share"), 1)+ require.NoError(t, err)+ _, _, err = module.Comments.List(ctx, outsider.SpaceID, postID, "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ require.NoError(t, module.Friends.DeleteFriendship(ctx, owner.SpaceID, friend.SpaceID))+ _, _, err = module.Comments.List(ctx, friend.SpaceID, postID, "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ require.ErrorIs(t, module.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "removed"}, []byte("cipher")), sql.ErrNoRows)+ _, err = module.Comments.React(ctx, friend.SpaceID, postID, "root", []byte("reaction"), "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ require.ErrorIs(t, module.Comments.Delete(ctx, friend.SpaceID, postID, "root"), sql.ErrNoRows)+ require.NoError(t, module.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: "after-removal"}, []byte("cipher")))+ items, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ require.Len(t, items, 2)+ require.True(t, items[0].CanDelete)+ require.True(t, items[1].CanDelete)+}++func TestCommentNotificationsGroupUniquePeopleByPost(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ otherID := insertSpaceUser(t, module, "[email protected]", "other-public")+ other, err := testCreateSpace(ctx, module, otherID, "group_commenter", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)+ require.NoError(t, testAddFriend(ctx, module, otherID, other.SpaceID, owner.SpaceID, "owner-share", 1, "other-share", 1))+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ otherPostID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "other-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, otherPostID, models.CreateCommentRequest{CommentID: "older-post"}, []byte("cipher")))+ for _, item := range []struct{ id, actor string }{{"first", friend.SpaceID}, {"second", other.SpaceID}, {"latest", friend.SpaceID}} {+ require.NoError(t, module.Comments.Create(ctx, item.actor, postID, models.CreateCommentRequest{CommentID: item.id}, []byte("cipher")))+ }+ page, cursor, err := module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.Len(t, page, 1)+ require.Equal(t, "latest", page[0].CommentID)+ require.Equal(t, int64(2), page[0].ActorCount)+ require.Len(t, page[0].Actors, 2)+ require.Equal(t, friend.SpaceID, page[0].Actors[0].SpaceID)+ require.Equal(t, other.SpaceID, page[0].Actors[1].SpaceID)+ require.Len(t, page[0].NotificationIDs, 3)+ require.True(t, page[0].Unread)+ older, _, err := module.Notifications.List(ctx, owner.SpaceID, cursor, 1)+ require.NoError(t, err)+ require.Len(t, older, 1)+ require.Equal(t, "older-post", older[0].CommentID)+ require.NoError(t, module.Notifications.MarkRead(ctx, owner.SpaceID, page[0].NotificationIDs[:1]))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.True(t, page[0].Unread)+ require.NoError(t, module.Notifications.MarkRead(ctx, owner.SpaceID, page[0].NotificationIDs))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.False(t, page[0].Unread)+ require.NoError(t, module.Comments.Create(ctx, other.SpaceID, postID, models.CreateCommentRequest{CommentID: "newest"}, []byte("cipher")))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.Equal(t, "newest", page[0].CommentID)+ require.True(t, page[0].Unread)+ require.Equal(t, int64(2), page[0].ActorCount)+ require.Len(t, page[0].NotificationIDs, 4)+ require.NoError(t, module.Comments.Delete(ctx, other.SpaceID, postID, "newest"))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.Equal(t, "latest", page[0].CommentID)+ require.False(t, page[0].Unread)+ require.NoError(t, module.Friends.DeleteFriendship(ctx, owner.SpaceID, other.SpaceID))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.Equal(t, int64(1), page[0].ActorCount)+ require.Len(t, page[0].Actors, 1)+ require.Len(t, page[0].NotificationIDs, 2)+}++func TestCommentActivityNotificationsGroupByExactTarget(t *testing.T) {+ for _, kind := range []string{"comment_reply", "comment_reaction"} {+ t.Run(kind, func(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ actors := []*SpaceRecord{friend}+ for _, name := range []string{"second", "third"} {+ id := insertSpaceUser(t, module, name+"[email protected]", name+"-public")+ actor, err := testCreateSpace(ctx, module, id, name+"_group", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)+ require.NoError(t, testAddFriend(ctx, module, id, actor.SpaceID, owner.SpaceID, "owner-share", 1, "actor-share", 1))+ actors = append(actors, actor)+ }+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ for _, item := range []struct{ id, replyTo string }{{"root", ""}, {"nested", "root"}, {"separate", ""}} {+ require.NoError(t, module.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: item.id, ReplyToID: item.replyTo}, []byte("cipher")))+ }+ addActivity := func(id, actor, target string) string {+ if kind == "comment_reaction" {+ _, err := module.Comments.React(ctx, actor, postID, target, []byte(id), "")+ require.NoError(t, err)+ return target+ }+ require.NoError(t, module.Comments.Create(ctx, actor, postID, models.CreateCommentRequest{CommentID: id, ReplyToID: target}, []byte("cipher")))+ return id+ }+ separateID := addActivity("separate-friend", friend.SpaceID, "separate")+ addActivity("nested-friend", friend.SpaceID, "nested")+ nestedID := addActivity("nested-other", actors[1].SpaceID, "nested")+ addActivity("root-first", friend.SpaceID, "root")+ addActivity("root-second", actors[1].SpaceID, "root")+ latestID := addActivity("root-latest", friend.SpaceID, "root")+ page, cursor, err := module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.Len(t, page, 1)+ group := page[0]+ require.Equal(t, kind, group.Kind)+ require.Equal(t, latestID, group.CommentID)+ if kind == "comment_reply" {+ require.Equal(t, "root", group.ReplyToID)+ require.Len(t, group.NotificationIDs, 3)+ require.Equal(t, friend.SpaceID, group.Actors[0].SpaceID)+ } else {+ require.Len(t, group.NotificationIDs, 2)+ require.Equal(t, actors[1].SpaceID, group.Actors[0].SpaceID)+ }+ require.EqualValues(t, 2, group.ActorCount)+ require.Len(t, group.Actors, 2)+ require.True(t, group.Unread)+ require.NotEmpty(t, cursor)+ older, nextCursor, err := module.Notifications.List(ctx, owner.SpaceID, cursor, 1)+ require.NoError(t, err)+ require.Len(t, older, 1)+ require.Equal(t, nestedID, older[0].CommentID)+ require.EqualValues(t, 2, older[0].ActorCount)+ if kind == "comment_reply" {+ require.Equal(t, "nested", older[0].ReplyToID)+ }+ oldest, _, err := module.Notifications.List(ctx, owner.SpaceID, nextCursor, 1)+ require.NoError(t, err)+ require.Len(t, oldest, 1)+ require.Equal(t, separateID, oldest[0].CommentID)+ require.NoError(t, module.Notifications.MarkRead(ctx, owner.SpaceID, group.NotificationIDs[:1]))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.True(t, page[0].Unread)+ require.NoError(t, module.Notifications.MarkRead(ctx, owner.SpaceID, group.NotificationIDs))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 2)+ require.NoError(t, err)+ require.False(t, page[0].Unread)+ require.True(t, page[1].Unread)+ newestID := addActivity("root-newest", actors[2].SpaceID, "root")+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.Equal(t, newestID, page[0].CommentID)+ require.EqualValues(t, 3, page[0].ActorCount)+ require.Len(t, page[0].Actors, 2)+ require.Equal(t, actors[2].SpaceID, page[0].Actors[0].SpaceID)+ require.Len(t, page[0].NotificationIDs, len(group.NotificationIDs)+1)+ require.True(t, page[0].Unread)+ if kind == "comment_reaction" {+ _, err = module.Comments.React(ctx, actors[2].SpaceID, postID, "root", nil, "")+ require.NoError(t, err)+ } else {+ require.NoError(t, module.Comments.Delete(ctx, actors[2].SpaceID, postID, newestID))+ }+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 1)+ require.NoError(t, err)+ require.Equal(t, latestID, page[0].CommentID)+ require.EqualValues(t, 2, page[0].ActorCount)+ require.False(t, page[0].Unread)+ require.NoError(t, module.Comments.Delete(ctx, owner.SpaceID, postID, "root"))+ page, _, err = module.Notifications.List(ctx, owner.SpaceID, "", 50)+ require.NoError(t, err)+ var remaining []string+ for _, item := range page {+ if item.Kind == kind {+ remaining = append(remaining, item.CommentID)+ }+ }+ require.Equal(t, []string{separateID}, remaining)+ })+ }+}++func TestNonFriendCommentNotificationsKeepOnlyDirectActivity(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, viewer := notificationTestSpaces(t, module)+ actorID := insertSpaceUser(t, module, "[email protected]", "actor-public")+ actor, err := testCreateSpace(ctx, module, actorID, "nonfriend_commenter", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)+ require.NoError(t, testAddFriend(ctx, module, actorID, actor.SpaceID, owner.SpaceID, "owner-share", 1, "actor-share", 1))+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ _, err = module.Notifications.DB.ExecContext(ctx, `UPDATE space_notifications SET read_at = 1 WHERE recipient_space_id = $1`, viewer.SpaceID)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, viewer.SpaceID, postID, models.CreateCommentRequest{CommentID: "root"}, []byte("cipher")))+ require.NoError(t, module.Comments.Create(ctx, actor.SpaceID, postID, models.CreateCommentRequest{CommentID: "ambient"}, []byte("cipher")))+ recipients, _, err := module.Comments.NotificationRecipients(ctx, actor.SpaceID, postID, "ambient", false)+ require.NoError(t, err)+ require.Len(t, recipients, 1)+ require.Equal(t, owner.OwnerID, recipients[0].UserID)+ _, err = module.Notifications.DB.ExecContext(ctx, `INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, comment_id) VALUES ('legacy-ambient', $1, $2, 'comment', 'ambient')`, viewer.SpaceID, actor.SpaceID)+ require.NoError(t, err)+ unread, err := module.Notifications.HasUnread(ctx, viewer.SpaceID)+ require.NoError(t, err)+ require.False(t, unread)+ require.NoError(t, module.Comments.Create(ctx, actor.SpaceID, postID, models.CreateCommentRequest{CommentID: "direct-reply", ReplyToID: "root"}, []byte("cipher")))+ _, err = module.Comments.React(ctx, actor.SpaceID, postID, "root", []byte("heart"), "")+ require.NoError(t, err)+ page, _, err := module.Notifications.List(ctx, viewer.SpaceID, "", 50)+ require.NoError(t, err)+ var directIDs []string+ var kinds []string+ for _, item := range page {+ if item.CommentID != "" {+ kinds = append(kinds, item.Kind)+ directIDs = append(directIDs, item.NotificationIDs...)+ require.Empty(t, item.Actors[0].EncryptedProfile)+ }+ }+ require.ElementsMatch(t, []string{"comment_reply", "comment_reaction"}, kinds)+ require.NoError(t, module.Notifications.MarkRead(ctx, viewer.SpaceID, append(directIDs, "legacy-ambient")))+ unread, err = module.Notifications.HasUnread(ctx, viewer.SpaceID)+ require.NoError(t, err)+ require.False(t, unread)+ var readAt sql.NullInt64+ require.NoError(t, module.Notifications.DB.QueryRowContext(ctx, `SELECT read_at FROM space_notifications WHERE notification_id = 'legacy-ambient'`).Scan(&readAt))+ require.False(t, readAt.Valid)+}++func TestDiscussionAccessRecheckedAfterConcurrentRemoval(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ tx, err := module.Comments.DB.BeginTx(ctx, nil)+ require.NoError(t, err)+ defer tx.Rollback()+ var backend int+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT pg_backend_pid()`).Scan(&backend))+ _, err = tx.ExecContext(ctx, `DELETE FROM space_friend_shares WHERE space_id = $1 AND friend_space_id = $2`, owner.SpaceID, friend.SpaceID)+ require.NoError(t, err)+ result := make(chan error, 1)+ go func() {+ _, _, err := module.Comments.List(ctx, friend.SpaceID, postID, "")+ result <- err+ }()+ require.Eventually(t, func() bool {+ var blocked bool+ err := module.Comments.DB.QueryRowContext(ctx, `SELECT EXISTS (SELECT 1 FROM pg_stat_activity WHERE $1 = ANY(pg_blocking_pids(pid)))`, backend).Scan(&blocked)+ return err == nil && blocked+ }, 3*time.Second, 10*time.Millisecond)+ require.NoError(t, tx.Commit())+ require.ErrorIs(t, <-result, sql.ErrNoRows)+}++func TestDiscussionReadsDoNotBlockOtherReadsOrPosts(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ otherPostID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "other-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "root"}, []byte("cipher")))+ tx, err := module.Comments.DB.BeginTx(ctx, nil)+ require.NoError(t, err)+ defer tx.Rollback()+ _, err = discussionPostTx(ctx, tx, friend.SpaceID, postID, false)+ require.NoError(t, err)++ ctx, cancel := context.WithTimeout(ctx, 3*time.Second)+ defer cancel()+ items, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ require.Len(t, items, 1)+ _, _, err = module.Comments.List(ctx, friend.SpaceID, otherPostID, "")+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, otherPostID, models.CreateCommentRequest{CommentID: "other"}, []byte("cipher")))+}++func TestDiscussionAcknowledgementOnlyReadsVisibleCommentNotifications(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ otherPostID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "other-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "visible"}, []byte("visible")))+ require.NoError(t, module.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: "reply", ReplyToID: "visible"}, []byte("reply")))+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, postID, models.CreateCommentRequest{CommentID: "offscreen"}, []byte("offscreen")))+ require.NoError(t, module.Comments.Create(ctx, friend.SpaceID, otherPostID, models.CreateCommentRequest{CommentID: "other-post"}, []byte("other-post")))+ items, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ require.Len(t, items[0].UnreadNotificationIDs, 1)+ require.Empty(t, items[1].UnreadNotificationIDs)+ require.Len(t, items[2].UnreadNotificationIDs, 1)+ friendItems, _, err := module.Comments.List(ctx, friend.SpaceID, postID, "")+ require.NoError(t, err)+ require.Empty(t, friendItems[0].UnreadNotificationIDs)+ require.Len(t, friendItems[1].UnreadNotificationIDs, 1)+ _, err = module.Comments.React(ctx, friend.SpaceID, postID, "reply", []byte("heart"), "")+ require.NoError(t, err)+ require.NoError(t, module.Notifications.MarkRead(ctx, owner.SpaceID, append(items[0].UnreadNotificationIDs, friendItems[1].UnreadNotificationIDs...)))+ updated, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ require.Empty(t, updated[0].UnreadNotificationIDs)+ require.Len(t, updated[1].UnreadNotificationIDs, 1)+ require.Equal(t, items[2].UnreadNotificationIDs, updated[2].UnreadNotificationIDs)+ other, _, err := module.Comments.List(ctx, owner.SpaceID, otherPostID, "")+ require.NoError(t, err)+ require.Len(t, other[0].UnreadNotificationIDs, 1)+ friendUpdated, _, err := module.Comments.List(ctx, friend.SpaceID, postID, "")+ require.NoError(t, err)+ require.Equal(t, friendItems[1].UnreadNotificationIDs, friendUpdated[1].UnreadNotificationIDs)+ require.NoError(t, module.Friends.DeleteFriendship(ctx, owner.SpaceID, friend.SpaceID))+ updated, _, err = module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ for _, item := range updated {+ require.Empty(t, item.UnreadNotificationIDs)+ }+}++func TestDiscussionReactionsStayWithTheirCommentAndPage(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, friend := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ otherPostID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "other-key", nil, 1, nil)+ require.NoError(t, err)+ _, err = module.Comments.DB.ExecContext(ctx, `INSERT INTO space_comments (comment_id, post_id, author_space_id, cipher, created_at)+ SELECT 'comment-' || lpad(n::text, 3, '0'), $1, $2, '\x00'::bytea, n FROM generate_series(1, 102) n`, postID, owner.SpaceID)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, owner.SpaceID, otherPostID, models.CreateCommentRequest{CommentID: "other-post"}, []byte("other")))+ for _, id := range []string{"comment-001", "comment-002", "comment-100", "comment-101"} {+ _, err := module.Comments.React(ctx, friend.SpaceID, postID, id, []byte(id), "")+ require.NoError(t, err)+ }+ _, err = module.Comments.React(ctx, owner.SpaceID, postID, "comment-001", []byte("owner-reaction"), "")+ require.NoError(t, err)+ _, err = module.Comments.React(ctx, friend.SpaceID, otherPostID, "other-post", []byte("other-reaction"), "")+ require.NoError(t, err)+ _, err = module.Comments.DB.ExecContext(ctx, `UPDATE space_comments SET cipher = NULL WHERE comment_id = 'comment-002'`)+ require.NoError(t, err)+ items, cursor, err := module.Comments.List(ctx, friend.SpaceID, postID, "")+ require.NoError(t, err)+ require.Len(t, items, 100)+ require.NotEmpty(t, cursor)+ require.Len(t, items[0].Reactions, 2)+ require.Empty(t, items[1].Reactions)+ require.Empty(t, items[2].Reactions)+ require.Len(t, items[99].Reactions, 1)+ require.Equal(t, []byte("comment-100"), items[99].Reactions[0].Cipher)+ items, cursor, err = module.Comments.List(ctx, friend.SpaceID, postID, cursor)+ require.NoError(t, err)+ require.Len(t, items, 2)+ require.Empty(t, cursor)+ require.Equal(t, "comment-101", items[0].ID)+ require.Len(t, items[0].Reactions, 1)+ require.Equal(t, []byte("comment-101"), items[0].Reactions[0].Cipher)+ require.Empty(t, items[1].Reactions)+}++func TestDiscussionAccountDeletionHidesAndRemovesBranches(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, alice := notificationTestSpaces(t, module)+ carolID := insertSpaceUser(t, module, "[email protected]", "carol-public")+ carol, err := testCreateSpace(ctx, module, carolID, "carol_deletion", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)+ for _, friend := range []*SpaceRecord{owner, alice} {+ require.NoError(t, testAddFriend(ctx, module, carolID, carol.SpaceID, friend.SpaceID, "share", 1, "share", 1))+ }+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ alicePostID, err := testCreatePost(ctx, module, alice.OwnerID, alice.SpaceID, "alice-post-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, carol.SpaceID, alicePostID, models.CreateCommentRequest{CommentID: "alice-post-comment"}, []byte("comment")))+ allIDs := []string{}+ for _, item := range []struct{ id, author, reply string }{+ {"owner-root", owner.SpaceID, ""},+ {"alice-reply", alice.SpaceID, "owner-root"},+ {"carol-nested", carol.SpaceID, "alice-reply"},+ {"owner-deep", owner.SpaceID, "carol-nested"},+ {"alice-deep", alice.SpaceID, "owner-deep"},+ {"owner-sibling", owner.SpaceID, "owner-root"},+ {"carol-sibling", carol.SpaceID, "owner-sibling"},+ {"alice-root", alice.SpaceID, ""},+ {"carol-child", carol.SpaceID, "alice-root"},+ {"owner-child", owner.SpaceID, "carol-child"},+ {"separate", carol.SpaceID, ""},+ {"delete-during-recovery", carol.SpaceID, "alice-root"},+ } {+ require.NoError(t, module.Comments.Create(ctx, item.author, postID, models.CreateCommentRequest{CommentID: item.id, ReplyToID: item.reply}, []byte(item.id)))+ allIDs = append(allIDs, item.id)+ }+ for _, item := range []struct{ actor, comment string }{+ {alice.SpaceID, "owner-root"},+ {carol.SpaceID, "owner-root"},+ {owner.SpaceID, "carol-nested"},+ {carol.SpaceID, "alice-root"},+ {owner.SpaceID, "separate"},+ {owner.SpaceID, "alice-post-comment"},+ } {+ targetPostID := postID+ if item.comment == "alice-post-comment" {+ targetPostID = alicePostID+ }+ _, err = module.Comments.React(ctx, item.actor, targetPostID, item.comment, []byte("reaction"), "")+ require.NoError(t, err)+ }+ assertVisible := func(expected []string) {+ t.Helper()+ items, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ visible := []string{}+ for _, item := range items {+ if len(item.Cipher) > 0 {+ visible = append(visible, item.ID)+ } else {+ require.Empty(t, item.Reactions, item.ID)+ require.Empty(t, item.UnreadNotificationIDs, item.ID)+ require.False(t, item.CanDelete, item.ID)+ }+ }+ require.ElementsMatch(t, expected, visible)+ post, err := module.Posts.GetPost(ctx, postID, owner.SpaceID)+ require.NoError(t, err)+ require.EqualValues(t, len(expected), post.CommentCount)+ feed, _, err := module.Posts.ListFeed(ctx, owner.SpaceID, "", 25)+ require.NoError(t, err)+ for _, post := range feed {+ if post.PostID == postID {+ require.EqualValues(t, len(expected), post.CommentCount)+ }+ }+ }+ assertVisible(allIDs)+ hiddenIDs := []string{"alice-reply", "carol-nested", "owner-deep", "alice-deep", "alice-root", "carol-child", "owner-child", "delete-during-recovery"}+ remainingIDs := []string{"owner-root", "owner-sibling", "carol-sibling", "separate"}+ require.NoError(t, module.ResetAccountDeletionAccess(ctx, alice.OwnerID))+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, alice.OwnerID)+ require.NoError(t, err)+ assertVisible(remainingIDs)+ _, _, err = module.Comments.List(ctx, alice.SpaceID, postID, "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ _, _, err = module.Comments.List(ctx, owner.SpaceID, alicePostID, "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ items, _, err := module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ require.Len(t, items[0].Reactions, 1)+ require.Equal(t, carol.SpaceID, items[0].Reactions[0].Actor.SpaceID)+ for _, id := range hiddenIDs {+ require.ErrorIs(t, module.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: "blocked-" + id, ReplyToID: id}, []byte("reply")), sql.ErrNoRows)+ _, err = module.Comments.React(ctx, owner.SpaceID, postID, id, []byte("reaction"), "")+ require.ErrorIs(t, err, sql.ErrNoRows)+ for _, actor := range []*SpaceRecord{owner, alice, carol} {+ for _, reaction := range []bool{false, true} {+ recipients, _, err := module.Comments.NotificationRecipients(ctx, actor.SpaceID, postID, id, reaction)+ require.NoError(t, err)+ require.Empty(t, recipients, id)+ }+ }+ }+ for _, viewer := range []*SpaceRecord{owner, carol} {+ notifications, _, err := module.Notifications.List(ctx, viewer.SpaceID, "", 50)+ require.NoError(t, err)+ for _, notification := range notifications {+ require.NotContains(t, hiddenIDs, notification.CommentID)+ require.NotEqual(t, alicePostID, notification.PostID.Int64)+ }+ }+ require.EqualValues(t, len(allIDs), countSpaceRows(t, module, `SELECT count(*) FROM space_comments WHERE post_id = $1 AND cipher IS NOT NULL`, postID))+ require.NoError(t, module.Comments.Delete(ctx, carol.SpaceID, postID, "delete-during-recovery"))+ require.NoError(t, module.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: "new-sibling", ReplyToID: "owner-sibling"}, []byte("new-sibling")))+ remainingIDs = append(remainingIDs, "new-sibling")+ assertVisible(remainingIDs)+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = '\x00'::bytea WHERE user_id = $1`, alice.OwnerID)+ require.NoError(t, err)+ assertVisible(append(allIDs[:len(allIDs)-1], "new-sibling"))+ items, _, err = module.Comments.List(ctx, owner.SpaceID, postID, "")+ require.NoError(t, err)+ require.Len(t, items[0].Reactions, 2)+ recipients, _, err := module.Comments.NotificationRecipients(ctx, owner.SpaceID, postID, "carol-nested", true)+ require.NoError(t, err)+ require.Len(t, recipients, 1)+ require.Equal(t, carolID, recipients[0].UserID)+ _, _, err = module.Comments.List(ctx, owner.SpaceID, alicePostID, "")+ require.NoError(t, err)+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, alice.OwnerID)+ require.NoError(t, err)+ require.NoError(t, module.DeleteUserData(ctx, alice.OwnerID))+ assertVisible(remainingIDs)+ require.EqualValues(t, len(remainingIDs), countSpaceRows(t, module, `SELECT count(*) FROM space_comments WHERE post_id = $1`, postID))+ for _, id := range hiddenIDs {+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_comments WHERE comment_id = $1`, id))+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_comment_reactions WHERE comment_id = $1`, id))+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_notifications WHERE comment_id = $1`, id))+ }+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_comments WHERE post_id = $1`, alicePostID))+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_comment_reactions WHERE comment_id = 'alice-post-comment' OR actor_space_id = $1`, alice.SpaceID))+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_notifications WHERE comment_id = 'alice-post-comment' OR actor_space_id = $1 OR recipient_space_id = $1`, alice.SpaceID))+ require.EqualValues(t, 1, countSpaceRows(t, module, `SELECT count(*) FROM space_comment_reactions WHERE comment_id = 'owner-root'`))+ require.EqualValues(t, 1, countSpaceRows(t, module, `SELECT count(*) FROM space_comment_reactions WHERE comment_id = 'separate'`))+ require.NoError(t, module.DeleteUserData(ctx, alice.OwnerID))+ require.NoError(t, module.DeleteUserData(ctx, owner.OwnerID))+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_comments WHERE post_id = $1`, postID))+}++func TestDiscussionAccountDeletionHidesUnreadActivityUntilRecovery(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, alice := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, alice.SpaceID, postID, models.CreateCommentRequest{CommentID: "root"}, []byte("root")))+ require.NoError(t, module.Comments.Create(ctx, owner.SpaceID, postID, models.CreateCommentRequest{CommentID: "reply", ReplyToID: "root"}, []byte("reply")))+ carolID := insertSpaceUser(t, module, "[email protected]", "carol-public")+ carol, err := testCreateSpace(ctx, module, carolID, "carol_unread", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)+ require.NoError(t, testAddFriend(ctx, module, carolID, carol.SpaceID, owner.SpaceID, "share", 1, "share", 1))+ _, err = module.Comments.React(ctx, carol.SpaceID, postID, "reply", []byte("reaction"), "")+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, carol.SpaceID, postID, models.CreateCommentRequest{CommentID: "nested", ReplyToID: "reply"}, []byte("nested")))+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE space_notifications SET read_at = 1 WHERE kind NOT IN ('comment_reaction', 'comment_reply')`)+ require.NoError(t, err)+ items, _, err := module.Notifications.List(ctx, owner.SpaceID, "", 50)+ require.NoError(t, err)+ var targetIDs []string+ for _, item := range items {+ if item.Kind == "comment_reaction" || item.Kind == "comment_reply" {+ require.True(t, item.Unread)+ targetIDs = append(targetIDs, item.NotificationIDs...)+ }+ }+ require.Len(t, targetIDs, 2)+ unread, err := module.Notifications.HasUnread(ctx, owner.SpaceID)+ require.NoError(t, err)+ require.True(t, unread)+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, alice.OwnerID)+ require.NoError(t, err)+ unread, err = module.Notifications.HasUnread(ctx, owner.SpaceID)+ require.NoError(t, err)+ require.False(t, unread)+ require.NoError(t, module.Notifications.MarkRead(ctx, owner.SpaceID, targetIDs))+ for _, id := range targetIDs {+ require.EqualValues(t, 1, countSpaceRows(t, module, `SELECT count(*) FROM space_notifications WHERE notification_id = $1 AND read_at IS NULL`, id))+ }+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = '\x00'::bytea WHERE user_id = $1`, alice.OwnerID)+ require.NoError(t, err)+ unread, err = module.Notifications.HasUnread(ctx, owner.SpaceID)+ require.NoError(t, err)+ require.True(t, unread)+ require.NoError(t, module.DeleteUserData(ctx, alice.OwnerID))+ unread, err = module.Notifications.HasUnread(ctx, owner.SpaceID)+ require.NoError(t, err)+ require.False(t, unread)+ for _, id := range targetIDs {+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_notifications WHERE notification_id = $1`, id))+ }+}++func TestDiscussionAccountCleanupWaitsForPendingReplies(t *testing.T) {+ module := newSpaceTestModule(t)+ ctx := t.Context()+ owner, alice := notificationTestSpaces(t, module)+ postID, err := testCreatePost(ctx, module, owner.OwnerID, owner.SpaceID, "post-key", nil, 1, nil)+ require.NoError(t, err)+ require.NoError(t, module.Comments.Create(ctx, alice.SpaceID, postID, models.CreateCommentRequest{CommentID: "root"}, []byte("root")))+ tx, err := module.Comments.DB.BeginTx(ctx, nil)+ require.NoError(t, err)+ defer tx.Rollback()+ _, err = discussionPostTx(ctx, tx, owner.SpaceID, postID, true)+ require.NoError(t, err)+ var backend int+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT pg_backend_pid()`).Scan(&backend))+ cleanupCtx, cancel := context.WithTimeout(ctx, 5*time.Second)+ defer cancel()+ result := make(chan error, 1)+ go func() {+ result <- module.DeleteUserData(cleanupCtx, alice.OwnerID)+ }()+ require.Eventually(t, func() bool {+ var blocked bool+ err := module.Comments.DB.QueryRowContext(ctx, `SELECT EXISTS (SELECT 1 FROM pg_stat_activity WHERE $1 = ANY(pg_blocking_pids(pid)))`, backend).Scan(&blocked)+ return err == nil && blocked+ }, 3*time.Second, 10*time.Millisecond)+ _, err = tx.ExecContext(ctx, `INSERT INTO space_comments (comment_id, post_id, author_space_id, parent_id, reply_to_id, cipher)+ VALUES ('pending-reply', $1, $2, 'root', 'root', $3)`, postID, owner.SpaceID, []byte("reply"))+ require.NoError(t, err)+ require.NoError(t, tx.Commit())+ require.NoError(t, <-result)+ require.Zero(t, countSpaceRows(t, module, `SELECT count(*) FROM space_comments WHERE post_id = $1`, postID))+}diff --git a/server/space/repo/module.go b/server/space/repo/module.goindex 050b89b328..a0ee435c22 100644--- a/server/space/repo/module.go+++ b/server/space/repo/module.go@@ -7,6 +7,7 @@ import ()type Module struct {+ Comments *CommentsRepositorySpaces *SpacesRepositoryPosts *PostsRepositoryFriends *FriendsRepository@@ -108,6 +109,7 @@ type SpacePostRecord struct {KeyVersion intCreatedAt int64ViewerLiked bool+ CommentCount int64}type SpacePostAssetRecord struct {@@ -268,6 +270,7 @@ type SpaceWebPushSubscriptionRecord struct {func NewModule(db *sql.DB, s3Config *s3config.S3Config) *Module {return &Module{+ Comments: &CommentsRepository{DB: db},Spaces: &SpacesRepository{DB: db},Posts: &PostsRepository{DB: db},Friends: &FriendsRepository{DB: db},diff --git a/server/space/repo/notifications.go b/server/space/repo/notifications.goindex bb56abb11a..79246c6b36 100644--- a/server/space/repo/notifications.go+++ b/server/space/repo/notifications.go@@ -20,6 +20,10 @@ type SpaceNotificationRecord struct {Actors []SpaceActorRecordActorCount int64PostID sql.NullInt64+ PostSpaceID string+ PostOwnerSlug string+ CommentID string+ ReplyToID stringFriendRequestID sql.NullInt64CreatedAt int64Unread bool@@ -28,13 +32,21 @@ type SpaceNotificationRecord struct {const notificationSourcesSQL = `FROM space_notifications nLEFT JOIN space_post_likes l ON l.like_id = n.post_like_id- LEFT JOIN space_posts p ON p.post_id = l.post_id AND p.is_deleted = FALSE+ LEFT JOIN space_comments c ON c.comment_id = n.comment_id AND c.cipher IS NOT NULL+ LEFT JOIN space_posts p ON p.post_id = COALESCE(l.post_id, c.post_id) AND p.is_deleted = FALSEJOIN spaces actor ON actor.space_id = n.actor_space_idJOIN users actor_owner ON actor_owner.user_id = actor.owner_id AND actor_owner.encrypted_email IS NOT NULL`const notificationVisibleSQL = `(n.kind = 'friend_request' OR (+ n.comment_id IS NOT NULL AND c.comment_id IS NOT NULL AND p.post_id IS NOT NULL+ AND EXISTS (SELECT 1 FROM spaces s JOIN users u ON u.user_id = s.owner_id AND u.encrypted_email IS NOT NULL WHERE s.space_id = p.space_id)+ AND ` + commentVisibleSQL + `+ AND (p.space_id = n.recipient_space_id OR EXISTS (SELECT 1 FROM space_friend_shares f WHERE f.space_id = p.space_id AND f.friend_space_id = n.recipient_space_id))+ AND (p.space_id = n.actor_space_id OR EXISTS (SELECT 1 FROM space_friend_shares f WHERE f.space_id = p.space_id AND f.friend_space_id = n.actor_space_id))+ AND (n.kind <> 'comment' OR p.space_id = n.recipient_space_id OR EXISTS (SELECT 1 FROM space_friend_shares f WHERE f.space_id = n.recipient_space_id AND f.friend_space_id = n.actor_space_id))+ ) OR (n.comment_id IS NULL AND(n.kind IN ('friend_accepted', 'poke') OR p.post_id IS NOT NULL)AND EXISTS (SELECT 1 FROM space_friend_shares shareWHERE share.space_id = n.recipient_space_id AND share.friend_space_id = n.actor_space_id)@@ -47,16 +59,22 @@ func (r *NotificationsRepository) List(ctx context.Context, recipientSpaceID, culimit = 100}query := `WITH visible AS (- SELECT n.*, l.post_id, CASE- WHEN n.kind = 'post_like' THEN l.post_id::text+ SELECT n.*, p.post_id, p.space_id AS post_space_id, c.reply_to_id, CASE+ WHEN n.kind IN ('post_like', 'comment') THEN p.post_id::text+ WHEN n.kind = 'comment_reaction' THEN n.comment_id+ WHEN n.kind = 'comment_reply' THEN c.reply_to_idWHEN n.kind IN ('friend_accepted', 'poke') THEN n.actor_space_idELSE n.notification_idEND AS group_id` + notificationSourcesSQL + ` WHERE n.recipient_space_id = $1 AND ` + notificationVisibleSQL + `), ranked AS (- SELECT notification_id, kind, actor_space_id, post_id, friend_request_id, created_at, group_id,- ROW_NUMBER() OVER (PARTITION BY kind, group_id ORDER BY created_at DESC, notification_id DESC) AS position+ SELECT notification_id, kind, actor_space_id, post_id, post_space_id, comment_id, reply_to_id, friend_request_id, created_at, group_id,+ ROW_NUMBER() OVER (PARTITION BY kind, group_id ORDER BY created_at DESC, notification_id DESC) AS position,+ ROW_NUMBER() OVER (PARTITION BY kind, group_id, actor_space_id ORDER BY created_at DESC, notification_id DESC) AS actor_positionFROM visible+ ), actors AS (+ SELECT *, ROW_NUMBER() OVER (PARTITION BY kind, group_id ORDER BY created_at DESC, notification_id DESC) AS actor_rank+ FROM ranked WHERE actor_position = 1), page AS (SELECT * FROM ranked WHERE position = 1`args := []any{recipientSpaceID}@@ -71,20 +89,21 @@ func (r *NotificationsRepository) List(ctx context.Context, recipientSpaceID, cuCOALESCE(ARRAY_AGG(visible.notification_id) FILTER (WHERE visible.kind <> 'poke' OR visible.read_at IS NULL), '{}') AS notification_ids,- CASE WHEN visible.kind = 'post_like' THEN COUNT(*) ELSE 1 END AS actor_count,+ COUNT(DISTINCT visible.actor_space_id) AS actor_count,BOOL_OR(visible.read_at IS NULL) AS unreadFROM visibleJOIN page ON page.kind = visible.kind AND page.group_id = visible.group_idGROUP BY visible.kind, visible.group_id)- SELECT page.notification_id, grouped.notification_ids, page.kind, page.post_id, page.friend_request_id, page.created_at, grouped.actor_count, grouped.unread, ` + spaceActorSelectColumns("actor", "avatar", "actor") + `+ SELECT page.notification_id, grouped.notification_ids, page.kind, page.post_id, COALESCE(page.post_space_id, ''), COALESCE(post_owner.space_slug, ''), COALESCE(page.comment_id, ''), COALESCE(page.reply_to_id, ''), page.friend_request_id, page.created_at, grouped.actor_count, grouped.unread, (actor.space_id = $1 OR EXISTS (SELECT 1 FROM space_friend_shares f WHERE f.space_id = actor.space_id AND f.friend_space_id = $1)), ` + spaceActorSelectColumns("actor", "avatar", "actor") + `FROM page+ LEFT JOIN spaces post_owner ON post_owner.space_id = page.post_space_idJOIN grouped ON grouped.kind = page.kind AND grouped.group_id = page.group_id- JOIN ranked sample ON sample.kind = page.kind AND sample.group_id = page.group_id- AND sample.position <= CASE WHEN page.kind = 'post_like' THEN 2 ELSE 1 END+ JOIN actors sample ON sample.kind = page.kind AND sample.group_id = page.group_id+ AND sample.actor_rank <= CASE WHEN page.kind IN ('post_like', 'comment', 'comment_reply', 'comment_reaction') THEN 2 ELSE 1 ENDJOIN spaces actor ON actor.space_id = sample.actor_space_id` + spaceActorAvatarJoin("actor", "avatar") + `- ORDER BY page.created_at DESC, page.notification_id DESC, sample.position`+ ORDER BY page.created_at DESC, page.notification_id DESC, sample.actor_rank`rows, err := r.DB.QueryContext(ctx, query, args...)if err != nil {return nil, "", stacktrace.Propagate(err, "")@@ -94,7 +113,8 @@ func (r *NotificationsRepository) List(ctx context.Context, recipientSpaceID, cufor rows.Next() {var item SpaceNotificationRecordvar actor SpaceActorRecord- dest := []any{&item.NotificationID, pq.Array(&item.NotificationIDs), &item.Kind, &item.PostID, &item.FriendRequestID, &item.CreatedAt, &item.ActorCount, &item.Unread}+ var private bool+ dest := []any{&item.NotificationID, pq.Array(&item.NotificationIDs), &item.Kind, &item.PostID, &item.PostSpaceID, &item.PostOwnerSlug, &item.CommentID, &item.ReplyToID, &item.FriendRequestID, &item.CreatedAt, &item.ActorCount, &item.Unread, &private}dest = append(dest, spaceActorScanDest(&actor)...)if err := rows.Scan(dest...); err != nil {return nil, "", stacktrace.Propagate(err, "")@@ -102,6 +122,14 @@ func (r *NotificationsRepository) List(ctx context.Context, recipientSpaceID, cuif len(items) == 0 || items[len(items)-1].NotificationID != item.NotificationID {items = append(items, item)}+ if !private {+ actor.EncryptedProfile = nil+ actor.PublicKey = nil+ actor.KeyVersion = 0+ actor.AvatarObjectID = sql.NullString{}+ actor.AvatarKeyVersion = sql.NullInt64{}+ actor.AvatarSize = sql.NullInt64{}+ }last := &items[len(items)-1]last.Actors = append(last.Actors, actor)}diff --git a/server/space/repo/posts.go b/server/space/repo/posts.goindex ccb58880b6..b8f75168bd 100644--- a/server/space/repo/posts.go+++ b/server/space/repo/posts.go@@ -48,7 +48,9 @@ func postRecordSelectSQL(viewerLikedExpr string) string {` + spaceActorSelectColumns("w", "w_avatar", "author") + `,p.encrypted_post_key, p.caption_cipher,p.key_version, p.created_at,- ` + viewerLikedExpr + ` AS viewer_liked`+ ` + viewerLikedExpr + ` AS viewer_liked,+ (SELECT COUNT(*) FROM space_comments c+ WHERE c.post_id = p.post_id AND ` + commentVisibleSQL + `) AS comment_count`}func scanPostRecords(rows *sql.Rows) ([]SpacePostRecord, error) {@@ -420,7 +422,7 @@ func scanPostRecord(scanner interface{ Scan(dest ...any) error }) (*SpacePostRecvar rec SpacePostRecorddest := []any{&rec.PostID, &rec.SpaceID, &rec.SpaceSlug, &rec.OwnerID}dest = append(dest, spaceActorScanDest(&rec.Author)...)- dest = append(dest, &rec.EncryptedPostKey, &rec.CaptionCipher, &rec.KeyVersion, &rec.CreatedAt, &rec.ViewerLiked)+ dest = append(dest, &rec.EncryptedPostKey, &rec.CaptionCipher, &rec.KeyVersion, &rec.CreatedAt, &rec.ViewerLiked, &rec.CommentCount)if err := scanner.Scan(dest...); err != nil {return nil, stacktrace.Propagate(err, "")}diff --git a/web/apps/space/src/components/AppNavigation.tsx b/web/apps/space/src/components/AppNavigation.tsxindex 283c6c2917..3c77be33fd 100644--- a/web/apps/space/src/components/AppNavigation.tsx+++ b/web/apps/space/src/components/AppNavigation.tsx@@ -55,13 +55,15 @@ export const SpaceAppLayout = ({ children }: { children: React.ReactNode }) => {typeof router.query.friend == "string" &&router.query.expanded == "1");const isNotificationsPage = router.pathname == spaceRoutes.notifications;+ const isPostPage = router.pathname.startsWith("/app/posts/");const showNavigation =isAppPage &&Boolean(profile) &&!isConversation &&!isSettingsPage &&!isProfilePage &&- !isNotificationsPage;+ !isNotificationsPage &&+ !isPostPage;const spaceID =isAppPage && profileLoadStatus == "ready"? profile?.spaceId@@ -192,6 +194,7 @@ export const SpaceAppLayout = ({ children }: { children: React.ReactNode }) => {data-space-settings={isSettingsPage || undefined}data-space-profile={isProfilePage || undefined}data-space-notifications={isNotificationsPage || undefined}+ data-space-post={isPostPage || undefined}>{children}{showNavigation && (diff --git a/web/apps/space/src/components/CommentComposer.tsx b/web/apps/space/src/components/CommentComposer.tsxnew file mode 100644index 0000000000..5187372271--- /dev/null+++ b/web/apps/space/src/components/CommentComposer.tsx@@ -0,0 +1,259 @@+import { Navigation03Icon } from "@hugeicons/core-free-icons";+import { HugeiconsIcon } from "@hugeicons/react";+import { Box } from "@mui/material";+import {+ spaceActionDoneDurationMs,+ SpaceActionFeedbackIcon,+ type SpaceActionPhase,+} from "components/ActionFeedback";+import React from "react";+import {+ spaceControlBackground,+ spaceControlBackgroundHover,+ spaceText,+ spaceTextMuted,+} from "styles/colors";+import { clampSpaceMessageText } from "utils/message-limits";++export const SpaceCommentsButton: React.FC<{+ backgroundColor?: string;+ hoverBackgroundColor?: string;+ count: number;+ disabled?: boolean;+ onClick: () => void;+}> = ({+ backgroundColor = spaceControlBackground,+ hoverBackgroundColor = spaceControlBackgroundHover,+ count,+ disabled,+ onClick,+}) => (+ <Box+ component="button"+ type="button"+ aria-label={`Open comments, ${count} ${count == 1 ? "comment" : "comments"}`}+ disabled={disabled}+ onClick={onClick}+ sx={{+ alignItems: "center",+ bgcolor: backgroundColor,+ border: 0,+ borderRadius: "24px",+ color: spaceText,+ cursor: "pointer",+ display: "flex",+ flex: "0 0 auto",+ font: "inherit",+ fontSize: 14,+ fontWeight: 500,+ gap: 1,+ height: 48,+ justifyContent: "center",+ minWidth: 68,+ px: 1.5,+ "&:disabled": { opacity: 0.4, cursor: "default" },+ "&:hover": { bgcolor: hoverBackgroundColor },+ "&:focus-visible": {+ outline: "2px solid #08C225",+ outlineOffset: 2,+ },+ }}+ >+ <svg+ width={28}+ height={28}+ viewBox="0 0 24 24"+ fill="none"+ stroke="currentColor"+ strokeWidth={1.8}+ strokeLinecap="round"+ strokeLinejoin="round"+ aria-hidden="true"+ style={{ transform: "translateY(-1px)" }}+ >+ <path d="M20 16.5A9.5 8.5 0 1 0 16.5 19.5L21.5 21Z" />+ </svg>+ <Box component="span" sx={{ color: "#C4C4C8" }}>+ {count}+ </Box>+ </Box>+);++export const SpaceCommentComposer: React.FC<{+ autoFocus?: boolean;+ onSend: (text: string) => Promise<void>;+ text?: string;+ onTextChange?: (text: string) => void;+ disabled?: boolean;+ sendDisabled?: boolean;+ placeholder?: string;+ inputRef?: React.RefObject<HTMLTextAreaElement | null>;+}> = ({+ autoFocus,+ onSend,+ text: draftText,+ onTextChange,+ disabled,+ sendDisabled,+ placeholder = "Add a commentโฆ",+ inputRef,+}) => {+ const [localText, setLocalText] = React.useState("");+ const text = draftText ?? localText;+ const setText = onTextChange ?? setLocalText;+ const [phase, setPhase] = React.useState<SpaceActionPhase | null>(null);+ const [error, setError] = React.useState(false);+ const internalRef = React.useRef<HTMLTextAreaElement>(null);+ const ref = inputRef ?? internalRef;+ React.useLayoutEffect(() => {+ const input = ref.current;+ if (!input) return;+ input.style.height = "46px";+ input.style.height = `${Math.min(input.scrollHeight, 112)}px`;+ }, [ref, text]);+ React.useEffect(() => {+ if (phase != "done") return;+ const timer = window.setTimeout(+ () => setPhase(null),+ spaceActionDoneDurationMs,+ );+ return () => window.clearTimeout(timer);+ }, [phase]);+ const send = async () => {+ if (!text.trim() || phase || disabled || sendDisabled) return;+ setPhase("busy");+ setError(false);+ try {+ await onSend(text);+ if (!onTextChange) setLocalText("");+ setPhase("done");+ } catch {+ setError(true);+ setPhase(null);+ }+ };+ return (+ <Box sx={{ flex: "1 1 auto", minWidth: 0 }}>+ <Box+ component="form"+ onSubmit={(event) => {+ event.preventDefault();+ void send();+ }}+ sx={{+ alignItems: "flex-end",+ border: "1px solid rgba(255, 255, 255, 0.08)",+ borderRadius: "24px",+ display: "flex",+ minWidth: 0,+ "&:focus-within": {+ borderColor: "rgba(255, 255, 255, 0.32)",+ },+ }}+ >+ <Box+ ref={ref}+ component="textarea"+ autoFocus={autoFocus}+ aria-label={+ placeholder.startsWith("Reply")+ ? "Reply to comment"+ : "Comment"+ }+ placeholder={placeholder}+ rows={1}+ value={text}+ disabled={disabled || phase != null}+ onChange={(event) =>+ setText(clampSpaceMessageText(event.target.value))+ }+ onKeyDown={(event) => {+ if (+ event.key == "Enter" &&+ !event.shiftKey &&+ !event.nativeEvent.isComposing+ ) {+ event.preventDefault();+ void send();+ }+ }}+ sx={{+ bgcolor: "transparent",+ border: 0,+ boxSizing: "border-box",+ color: spaceText,+ flex: "1 1 auto",+ font: "inherit",+ fontSize: 14,+ lineHeight: "20px",+ minHeight: 46,+ minWidth: 0,+ outline: 0,+ p: "13px 16px",+ resize: "none",+ "&::placeholder": { color: spaceTextMuted },+ }}+ />+ {(text.trim() || phase) && (+ <Box+ component="button"+ type="submit"+ className={phase == "done" ? undefined : "green-bg"}+ aria-label={+ phase == "done"+ ? "Comment sent"+ : phase == "busy"+ ? "Sending comment"+ : "Send comment"+ }+ disabled={disabled || sendDisabled || phase != null}+ sx={{+ alignItems: "center",+ bgcolor:+ phase == "done" ? "transparent" : "#08C225",+ border: 0,+ borderRadius: "50%",+ color: spaceText,+ cursor:+ disabled || sendDisabled || phase+ ? "default"+ : "pointer",+ display: "flex",+ flexShrink: 0,+ height: 36,+ justifyContent: "center",+ m: "5px",+ width: 36,+ opacity:+ (disabled || sendDisabled) && !phase ? 0.4 : 1,+ "&:focus-visible": {+ outline: "2px solid #08C225",+ outlineOffset: 2,+ },+ }}+ >+ <SpaceActionFeedbackIcon+ phase={phase}+ size={22}+ idleIcon={+ <HugeiconsIcon+ icon={Navigation03Icon}+ size={20}+ strokeWidth={1.8}+ />+ }+ />+ </Box>+ )}+ </Box>+ {error && (+ <Box+ role="alert"+ sx={{ color: spaceTextMuted, fontSize: 12, px: 1, pt: 1 }}+ >+ Couldnโt send. Please try again.+ </Box>+ )}+ </Box>+ );+};diff --git a/web/apps/space/src/components/FileViewer.tsx b/web/apps/space/src/components/FileViewer.tsxindex 110ef40af6..2ee5af60f3 100644--- a/web/apps/space/src/components/FileViewer.tsx+++ b/web/apps/space/src/components/FileViewer.tsx@@ -21,9 +21,11 @@ import {import { SpaceAvatarImage } from "components/AvatarImage";import { SpaceBottomSheetTransition } from "components/BottomSheetTransition";import { SpaceCaptionText } from "components/CaptionText";+import { SpaceCommentsButton } from "components/CommentComposer";import { ConfirmationActionSheet } from "components/ConfirmationActionSheet";import { spacePostLikePopDurationMs } from "components/post-like-animation";import { paintStretchingDot } from "components/post-photos-dots";+import { PostComments } from "components/PostComments";import { SpacePostPhotosDots } from "components/PostPhotosDots";import { SpacePostReplyControls } from "components/PostReplyControls";import { createSpaceVideoContent } from "components/PostVideoContent";@@ -36,6 +38,8 @@ import {viewerOriginKey,} from "components/viewer-transition";import log from "ente-base/log";+import { useCommentCount } from "hooks/use-comment-count";+import { useCommentDraft } from "hooks/use-comment-draft";import { isSpaceIOS } from "hooks/use-pwa-install-prompt";import type PhotoSwipe from "photoswipe";import React from "react";@@ -46,6 +50,7 @@ import type {SpacePostAssetURLLoader,SpacePostVideo,} from "services/space";+import { useSpaceAppState } from "state/app-state";import {spaceControlBackground,spaceControlBackgroundHover,@@ -144,6 +149,7 @@ export interface SpaceViewerPhoto {alt?: string;avatarUrl?: string | null;caption?: string;+ commentCount?: number;friendID?: string;height?: number;imageUrl: string;@@ -199,7 +205,10 @@ interface SpaceFileViewerProps {photoIndex?: number;initialPhotoIndex?: number;photos?: SpaceViewerPhoto[];- focusReplyOnOpen?: boolean;+ commentsOnOpen?: boolean;+ targetCommentId?: string;+ focusCommentOnOpen?: boolean;+ privateReplyOnOpen?: boolean;postActionMode?: SpaceViewerPostActionMode;}@@ -405,16 +414,17 @@ const SpaceViewerPhotoOverlay: React.FC<{data-space-viewer-chrome="true"sx={{alignItems: "center",- bottom: "14%",display: "flex",flexDirection: "column",gap: "16px",- left: "50%",+ bottom: {+ sm: "max(88px, calc(env(safe-area-inset-bottom) + 80px))",+ },+ left: { sm: "50%" },pointerEvents: "none",- position: "fixed",- transform: "translateX(-50%)",- width: "78vw",- zIndex: 2,+ position: { sm: "fixed" },+ transform: { sm: "translateX(-50%)" },+ width: { xs: "100%", sm: "78vw" },}}><SpacePostPhotosDots@@ -466,7 +476,10 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({headerHeight = 68,draftPhotoControls,onLoadPhoto,- focusReplyOnOpen = false,+ commentsOnOpen = false,+ targetCommentId,+ focusCommentOnOpen = false,+ privateReplyOnOpen = false,isDraftPostPreviewPending = false,onClose,onAddDraftPhoto,@@ -487,6 +500,11 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({photos,postActionMode = "like-only",}) => {+ const { profile } = useSpaceAppState();+ const [commentsOpen, setCommentsOpen] = React.useState(false);+ React.useEffect(() => {+ if (commentsOnOpen) setCommentsOpen(true);+ }, [commentsOnOpen]);const [localPhotoIndex, setLocalPhotoIndex] =React.useState(initialPhotoIndex);const [loadedPhotoURLs, setLoadedPhotoURLs] = React.useState<@@ -537,6 +555,10 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({viewerPhotos.length - 1,);const activePhoto = viewerPhotos[activePhotoIndex] ?? photo;+ const [commentDraft, setCommentDraft] = useCommentDraft(+ profile?.spaceId,+ activePhoto.postId,+ );const draftPostPreparationError = isDraftPost? activePhoto.preparationError: undefined;@@ -601,8 +623,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({isCaptionEditingRef.current = isCaptionEditing;const [replyText, setReplyText] = React.useState("");const replyDraftsRef = React.useRef(new Map<string, string>());- const [isReplyFocused, setIsReplyFocused] =- React.useState(focusReplyOnOpen);+ const [isReplyFocused, setIsReplyFocused] = React.useState(false);const [replyPhases, setReplyPhases] = React.useState<Record<string, SpaceActionPhase | null>>({});@@ -645,6 +666,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({const captionInputRef = React.useRef<HTMLTextAreaElement | null>(null);const cancelKeyboardDismissWaitRef = React.useRef<() => void>(undefined);const replyInputRef = React.useRef<HTMLTextAreaElement | null>(null);+ const replyControlsRef = React.useRef<HTMLDivElement | null>(null);const [actionsAnchor, setActionsAnchor] =React.useState<HTMLElement | null>(null);const [deleteSheetOpen, setDeleteSheetOpen] = React.useState(false);@@ -671,6 +693,13 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({const canAddFriendForPostAction = Boolean(!isDraftPost && onAddFriendForPostAction,);+ const canComment = Boolean(+ !isDraftPost &&+ !canAddFriendForPostAction &&+ profile?.spaceId &&+ activePhoto.postId &&+ activePhoto.spaceId,+ );const canReplyToPost = Boolean(!isDraftPost &&(canAddFriendForPostAction ||@@ -680,8 +709,12 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({onReplyToPost)),);const isReplyMode =- canReplyToPost &&- (isReplyFocused || replyText.trim().length > 0 || isReplyActionRunning);+ canReplyToPost && (isReplyFocused || isReplyActionRunning);+ const commentCount = useCommentCount(+ profile?.spaceId,+ activePhoto.postId,+ activePhoto.commentCount,+ );const canSendReply =canReplyToPost &&!isReplyActionRunning &&@@ -689,6 +722,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({const isSwipeBlockedRef = React.useRef(false);isSwipeBlockedRef.current =isActionsOpen ||+ commentsOpen ||addFriendSheetOpen ||(canDeletePost && deleteSheetOpen) ||isDeleteExit ||@@ -744,6 +778,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({requestCloseRef.current = (throwVelocity = { x: 0, y: 0 }) => {const motion = motionRef.current;if (motion.closing) return;+ motion.closing = true;const root = viewerRootRef.current;const pswp = pswpRef.current;const item =@@ -802,7 +837,6 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({startBackground,);}- motion.closing = true;onCloseRef.current();};@@ -1072,6 +1106,11 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({};const handleReplyKeyDown = (event: React.KeyboardEvent) => {+ if (event.key == "Escape") {+ event.stopPropagation();+ replyInputRef.current?.blur();+ return;+ }if (canAddFriendForPostAction &&(event.key == "Enter" || event.key == " ")@@ -1109,13 +1148,6 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({input.setSelectionRange(input.value.length, input.value.length);}, [isCaptionEditing]);- React.useLayoutEffect(() => {- if (!focusReplyOnOpen || !canReplyToPost) return;-- setIsReplyFocused(true);- replyInputRef.current?.focus();- }, [canReplyToPost, focusReplyOnOpen, activePhoto.postId]);-React.useEffect(() => {if (deleteActionPhase != "done") return;@@ -1143,7 +1175,8 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({const timeoutID = window.setTimeout(() => {setReplyActionPhase(null);- setIsReplyFocused(false);+ if (!replyControlsRef.current?.contains(document.activeElement))+ setIsReplyFocused(false);}, viewerActionDoneDurationMs);return () => window.clearTimeout(timeoutID);@@ -1169,8 +1202,13 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({React.useLayoutEffect(() => {setReplyText(replyDraftsRef.current.get(activeReplyKey) ?? "");- setIsReplyFocused(focusReplyOnOpen && canReplyToPost);- }, [activeReplyKey, canReplyToPost, focusReplyOnOpen]);+ setIsReplyFocused(false);+ }, [activeReplyKey]);++ React.useLayoutEffect(() => {+ if (privateReplyOnOpen && canReplyToPost)+ replyInputRef.current?.focus();+ }, [canReplyToPost, privateReplyOnOpen]);React.useEffect(() => {setPhotoLikePopID(0);@@ -1260,7 +1298,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({}, [hasDraftPhotoControls]);React.useEffect(() => {- if (!isSpaceIOS() || !canReplyToPost) return;+ if (!isSpaceIOS() || (!canReplyToPost && !canComment)) return;const viewport = window.visualViewport;if (!viewport) return;@@ -1282,7 +1320,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({viewport.removeEventListener("resize", updateReplyViewport);viewport.removeEventListener("scroll", updateReplyViewport);};- }, [canReplyToPost]);+ }, [canReplyToPost, canComment]);const handleDeleteSheetExited = () => {if (!isDeleteExit) return;@@ -1323,7 +1361,9 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({if (!input || document.activeElement != input) return;if (event.target instanceof Element &&- event.target.closest("[data-space-viewer-bottom='true']")+ event.target.closest(+ "[data-space-viewer-bottom='true'], [data-space-viewer-close]",+ )) {return;}@@ -1802,7 +1842,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({"& > .pswp, & > header, & > [data-space-viewer-chrome='true']":{translate:- isSpaceIOS() && canReplyToPost+ isSpaceIOS() && (canReplyToPost || canComment)? "0 calc(-1 * var(--space-keyboard-inset, 0px))": undefined,},@@ -2102,6 +2142,11 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({data-space-viewer-closedisabled={isDraftPostActionRunning}onClick={closeViewer}+ onPointerDown={+ isReplyFocused+ ? handleInputActionPointerDown+ : undefined+ }sx={{ ...draftHeaderButtonSx, color: "#C0C0C0" }}><HugeiconsIcon@@ -2709,6 +2754,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({)}{!isDraftPost &&(hasDisplayCaption ||+ canComment ||showPhotoLikeButton ||postPhotoCount > 1) &&!isCaptionEditing && (@@ -2721,7 +2767,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({: "max(24px, calc(env(safe-area-inset-bottom) + 16px))",display: "flex",flexDirection: "column",- gap: "12px",+ gap: "20px",left: { xs: "16px", sm: "auto" },maxWidth: { sm: 390 },position: "fixed",@@ -2741,14 +2787,34 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({photoCount={postPhotoCount}/>)}- {showPhotoLikeButton && (+ {showPhotoLikeButton || canReplyToPost ? (<SpacePostReplyControls+ ref={replyControlsRef}canSendReply={canSendReply}+ commentsButton={+ canComment ? (+ <SpaceCommentsButton+ count={commentCount}+ onClick={() =>+ setCommentsOpen(true)+ }+ />+ ) : undefined+ }isReplyMode={isReplyMode}liked={isPhotoLiked}likePopID={photoLikePopID}likeToggleID={photoLikeToggleID}postKey={activePostKey}+ onBlur={(event) => {+ if (+ !motionRef.current.closing &&+ !event.currentTarget.contains(+ event.relatedTarget,+ )+ )+ setIsReplyFocused(false);+ }}onLike={handlePhotoLikeClick}onSendReply={sendReply}replyActionPhase={replyActionPhase}@@ -2756,8 +2822,6 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({replyInputProps={canReplyToPost? {- onBlur: () =>- setIsReplyFocused(false),onChange: (event) => {const nextText =clampSpaceMessageText(@@ -2783,9 +2847,34 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({: undefined}/>- )}+ ) : canComment ? (+ <Box+ sx={{+ display: "flex",+ justifyContent: "flex-end",+ }}+ >+ <SpaceCommentsButton+ count={commentCount}+ onClick={() => setCommentsOpen(true)}+ />+ </Box>+ ) : null}</Box>)}+ {commentsOpen && canComment && (+ <PostComments+ key={activePhoto.postId}+ autoFocus={focusCommentOnOpen}+ targetCommentId={targetCommentId}+ viewer={profile!.spaceId!}+ postId={activePhoto.postId!}+ owner={activePhoto.spaceId!}+ draft={commentDraft}+ setDraft={setCommentDraft}+ onClose={() => setCommentsOpen(false)}+ />+ )}<Modalopen={isCaptionDialogOpen}onClose={() => setIsCaptionDialogOpen(false)}diff --git a/web/apps/space/src/components/MessageActionMenu.tsx b/web/apps/space/src/components/MessageActionMenu.tsxnew file mode 100644index 0000000000..d0b5007bf3--- /dev/null+++ b/web/apps/space/src/components/MessageActionMenu.tsx@@ -0,0 +1,130 @@+import { Box, MenuItem, MenuList } from "@mui/material";+import React from "react";+import {+ spaceDanger,+ spaceMenuBackground,+ spaceMenuHover,+ spaceText,+} from "styles/colors";+import { spaceTouchTargetSize } from "styles/touch-targets";++export const ReplyIcon: React.FC = () => (+ <svg+ width="12"+ height="9"+ viewBox="0 0 12 9"+ fill="none"+ xmlns="http://www.w3.org/2000/svg"+ >+ <path+ fillRule="evenodd"+ clipRule="evenodd"+ d="M4.5241 0.242677C4.62341 0.34442 4.67919 0.482337 4.67919 0.626134C4.67919 0.76993 4.62341 0.907847 4.5241 1.00959L1.89369 3.70102H7.68483C8.3587 3.70102 9.35854 3.9036 10.2042 4.52653C11.0775 5.17045 11.7507 6.23762 11.7507 7.86116C11.7507 8.00507 11.6948 8.14309 11.5953 8.24485C11.4959 8.34661 11.361 8.40378 11.2203 8.40378C11.0797 8.40378 10.9448 8.34661 10.8453 8.24485C10.7459 8.14309 10.69 8.00507 10.69 7.86116C10.69 6.59069 10.1844 5.84982 9.58481 5.40776C8.95761 4.94544 8.18899 4.78627 7.68483 4.78627H1.89369L4.5241 7.4777C4.5762 7.52738 4.61799 7.58728 4.64698 7.65384C4.67597 7.72041 4.69155 7.79226 4.69281 7.86512C4.69406 7.93798 4.68096 8.01035 4.65429 8.07791C4.62762 8.14548 4.58792 8.20686 4.53756 8.25839C4.4872 8.30991 4.42722 8.35053 4.36118 8.37782C4.29515 8.40512 4.22442 8.41852 4.15321 8.41723C4.082 8.41595 4.01178 8.4 3.94673 8.37034C3.88167 8.34068 3.82313 8.29792 3.77457 8.24461L0.23908 4.6271C0.139767 4.52536 0.0839844 4.38744 0.0839844 4.24364C0.0839844 4.09985 0.139767 3.96193 0.23908 3.86019L3.77457 0.242677C3.87401 0.141061 4.0088 0.0839844 4.14934 0.0839844C4.28987 0.0839844 4.42466 0.141061 4.5241 0.242677Z"+ fill="currentColor"+ stroke="currentColor"+ strokeWidth="0.166667"+ />+ </svg>+);++export const DeleteIcon: React.FC = () => (+ <svg+ width="13"+ height="15"+ viewBox="0 0 13 15"+ fill="none"+ xmlns="http://www.w3.org/2000/svg"+ >+ <path+ d="M11.5 2.83203L11.0869 9.51543C10.9813 11.223 10.9285 12.0768 10.5005 12.6906C10.2889 12.9941 10.0165 13.2502 9.70047 13.4427C9.0614 13.832 8.206 13.832 6.49513 13.832C4.78208 13.832 3.92553 13.832 3.28603 13.442C2.96987 13.2492 2.69733 12.9926 2.48579 12.6886C2.05792 12.0738 2.0063 11.2188 1.90307 9.50883L1.5 2.83203M0.5 2.83333H12.5M9.2038 2.83333L8.74873 1.89449C8.4464 1.27084 8.2952 0.959013 8.03447 0.76454C7.97667 0.7214 7.9154 0.683027 7.85133 0.6498C7.5626 0.5 7.21607 0.5 6.523 0.5C5.81253 0.5 5.45733 0.5 5.16379 0.65608C5.09873 0.690673 5.03665 0.7306 4.97819 0.775447C4.71443 0.9778 4.56709 1.30103 4.27241 1.94751L3.86861 2.83333M4.83203 10.166V6.16602M8.16797 10.166V6.16602"+ stroke="currentColor"+ strokeLinecap="round"+ />+ </svg>+);++export const CopyIcon: React.FC = () => (+ <svg+ width="14"+ height="14"+ viewBox="0 0 14 14"+ fill="none"+ xmlns="http://www.w3.org/2000/svg"+ >+ <path+ d="M4.5 4.5V2.5C4.5 1.39543 5.39543 0.5 6.5 0.5H11.5C12.6046 0.5 13.5 1.39543 13.5 2.5V7.5C13.5 8.60457 12.6046 9.5 11.5 9.5H9.5M2.5 4.5H7.5C8.60457 4.5 9.5 5.39543 9.5 6.5V11.5C9.5 12.6046 8.60457 13.5 7.5 13.5H2.5C1.39543 13.5 0.5 12.6046 0.5 11.5V6.5C0.5 5.39543 1.39543 4.5 2.5 4.5Z"+ stroke="currentColor"+ strokeLinecap="round"+ strokeLinejoin="round"+ />+ </svg>+);++export const MessageActionMenuItem: React.FC<{+ icon: React.ReactNode;+ label: string;+ onClick: () => void;+ tone?: "default" | "danger";+}> = ({ icon, label, onClick, tone = "default" }) => (+ <MenuItem+ disableRipple+ onClick={onClick}+ sx={{+ WebkitTapHighlightColor: "transparent",+ borderRadius: "12px",+ color: tone == "danger" ? spaceDanger : spaceText,+ gap: "8px",+ minHeight: spaceTouchTargetSize,+ outline: 0,+ px: "8px",+ py: "7px",+ "&.Mui-focusVisible": {+ bgcolor:+ tone == "danger"+ ? "rgba(246, 58, 58, 0.14)"+ : spaceMenuHover,+ outline: 0,+ },+ "&:focus": { outline: 0 },+ "&:focus-visible": { outline: 0 },+ "&:hover": {+ bgcolor:+ tone == "danger"+ ? "rgba(246, 58, 58, 0.14)"+ : spaceMenuHover,+ },+ }}+ >+ {icon}+ <Box+ sx={{+ fontFamily: '"Inter Variable", Inter, sans-serif',+ fontSize: 13,+ fontWeight: 650,+ lineHeight: "18px",+ }}+ >+ {label}+ </Box>+ </MenuItem>+);++const messageActionMenuListSx = {+ alignSelf: "flex-start",+ bgcolor: spaceMenuBackground,+ borderRadius: "16px",+ boxShadow:+ "0 0 0 1px rgba(255, 255, 255, 0.08), 0 8px 24px rgba(0, 0, 0, 0.32)",+ minWidth: 132,+ outline: 0,+ p: "4px",+ width: "max-content",+ "&:focus": { outline: 0 },+ "&:focus-visible": { outline: 0 },+};++export const MessageActionMenuList: React.FC<+ React.ComponentProps<typeof MenuList>+> = (props) => (+ <MenuList {...props} sx={messageActionMenuListSx} variant="menu" />+);diff --git a/web/apps/space/src/components/MessageReactionPicker.tsx b/web/apps/space/src/components/MessageReactionPicker.tsxindex 3a759c6ba3..abe243ba17 100644--- a/web/apps/space/src/components/MessageReactionPicker.tsx+++ b/web/apps/space/src/components/MessageReactionPicker.tsx@@ -65,10 +65,11 @@ const buttonSx = {};export const MessageQuickReactions: React.FC<{+ label?: string;selected?: string;onSelect: (emoji: string) => void;onMore: () => void;-}> = ({ selected, onSelect, onMore }) => {+}> = ({ selected, onSelect, onMore, label = "React to message" }) => {const groupRef = React.useRef<HTMLDivElement>(null);React.useEffect(() => {groupRef.current?.focus({ preventScroll: true });@@ -78,7 +79,7 @@ export const MessageQuickReactions: React.FC<{<Boxref={groupRef}role="group"- aria-label="React to message"+ aria-label={label}tabIndex={-1}sx={{bgcolor: spaceMenuBackground,@@ -156,10 +157,11 @@ const skinTones = [const tonePickerWidth = skinTones.length * 40 + 8;export const MessageReactionPicker: React.FC<{+ label?: string;selected?: string;onSelect: (emoji: string) => void;onClose: () => void;-}> = ({ selected, onSelect, onClose }) => {+}> = ({ selected, onSelect, onClose, label = "React to message" }) => {const isBottomSheet = useMediaQuery("(max-width: 599px)");const prefersReducedMotion = useMediaQuery("(prefers-reduced-motion: reduce)",@@ -230,7 +232,7 @@ export const MessageReactionPicker: React.FC<{sx={{ zIndex: 1500 }}slotProps={{paper: {- "aria-label": "React to message",+ "aria-label": label,style: {translate: `0 ${dragOffset}px`,transition:diff --git a/web/apps/space/src/components/PostComments.tsx b/web/apps/space/src/components/PostComments.tsxnew file mode 100644index 0000000000..374b816657--- /dev/null+++ b/web/apps/space/src/components/PostComments.tsx@@ -0,0 +1,1432 @@+import { ArrowLeft02Icon } from "@hugeicons/core-free-icons";+import { HugeiconsIcon } from "@hugeicons/react";+import {+ Box,+ CircularProgress,+ ClickAwayListener,+ Dialog,+ Grow,+ Popper,+ useMediaQuery,+} from "@mui/material";+import { SpaceAvatarImage } from "components/AvatarImage";+import { SpaceBottomSheetTransition } from "components/BottomSheetTransition";+import { SpaceCommentComposer } from "components/CommentComposer";+import {+ CopyIcon,+ DeleteIcon,+ MessageActionMenuItem,+ MessageActionMenuList,+ ReplyIcon,+} from "components/MessageActionMenu";+import {+ MessageQuickReactions,+ MessageReactionPicker,+} from "components/MessageReactionPicker";+import { ReplyComposerPreview } from "components/ReplyComposerPreview";+import type { FriendProfile } from "data/friends";+import log from "ente-base/log";+import { useBrowserBackClose } from "hooks/use-browser-back-close";+import { isSpaceIOS } from "hooks/use-pwa-install-prompt";+import React from "react";+import { flushSync } from "react-dom";+import {+ createCurrentComment,+ deleteCurrentComment,+ loadCurrentComments,+ loadCurrentFriendAvatarURL,+ markCurrentNotificationItemsRead,+ removeCurrentCommentReaction,+ setCurrentCommentReaction,+ type SpaceComment,+} from "services/space";+import {+ spaceControlBackgroundHover,+ spaceDialogBackground,+ spaceSurface,+ spaceText,+ spaceTextMuted,+} from "styles/colors";+import {+ commentReactionPreview,+ commentThreads,+ groupCommentReactions,+ validateCommentReplyTarget,+ type CommentDraft,+} from "utils/comments";+import { firstNameFrom, formatSpaceDate } from "utils/display";+import { useSpaceRouter } from "utils/route-transitions";+import { spaceRoutes } from "utils/routes";++const messageActionsTransitionDuration = { enter: 300, exit: 100 };++const textActionSx = {+ appearance: "none",+ bgcolor: "transparent",+ border: 0,+ borderRadius: "8px",+ color: spaceTextMuted,+ cursor: "pointer",+ font: "inherit",+ fontSize: 12,+ fontWeight: 500,+ minHeight: 32,+ p: 0,+ "&:hover": { color: spaceText },+ "&:disabled": { cursor: "default", opacity: 0.4 },+ "&:focus-visible": { outline: "2px solid #08C225", outlineOffset: 3 },+};++const CommentIdentity: React.FC<{+ actor: FriendProfile;+ viewer: string;+ inline?: boolean;+}> = ({ actor, viewer, inline = false }) => {+ const router = useSpaceRouter();+ const [avatar, setAvatar] = React.useState<string | null>(null);+ React.useEffect(() => {+ let active = true;+ setAvatar(null);+ if (actor.avatarObjectID)+ void loadCurrentFriendAvatarURL(actor, viewer)+ .then((url) => {+ if (active) setAvatar(url);+ })+ .catch(() => {+ if (active) setAvatar(null);+ });+ return () => {+ active = false;+ };+ }, [actor, viewer]);+ return (+ <Box+ component="button"+ type="button"+ onClick={() =>+ void router.push(+ spaceRoutes.friendPage,+ spaceRoutes.friend(actor.username),+ )+ }+ sx={{+ ...textActionSx,+ alignItems: "center",+ display: inline ? "inline-flex" : "flex",+ fontSize: inline ? 13 : 14,+ fontWeight: 600,+ minHeight: inline ? 0 : 24,+ lineHeight: inline ? "18px" : "20px",+ color: spaceText,+ p: 0,+ minWidth: 0,+ overflowWrap: "anywhere",+ textAlign: "left",+ textTransform: "none",+ gap: 1,+ }}+ >+ <Box+ component="span"+ sx={{+ display: "block",+ width: inline ? 28 : 22,+ height: inline ? 28 : 22,+ flexShrink: 0,+ ...(inline+ ? { position: "absolute", left: 0, top: 0 }+ : {}),+ }}+ >+ <SpaceAvatarImage+ src={avatar ?? undefined}+ alt=""+ borderRadius="50%"+ />+ </Box>+ {(inline ? firstNameFrom(actor.fullName) : actor.fullName) ||+ `@${actor.username}`}+ </Box>+ );+};++const CommentRow: React.FC<{+ comment: SpaceComment;+ recipient?: SpaceComment;+ viewer: string;+ highlighted: boolean;+ disabled: boolean;+ onOpenActions: (+ anchor: HTMLElement,+ source: "touch" | "contextmenu",+ ) => void;+ onOpenReactions: () => void;+}> = ({+ comment,+ recipient,+ viewer,+ highlighted,+ disabled,+ onOpenActions,+ onOpenReactions,+}) => {+ const timer = React.useRef<number | undefined>(undefined);+ const start = React.useRef<+ { pointerId: number; x: number; y: number } | undefined+ >(undefined);+ const didOpen = React.useRef(false);+ const canOpenActions = !disabled && !comment.deleted;+ const hasReactions = !comment.deleted && comment.reactions.length > 0;+ const topReactions = commentReactionPreview(comment.reactions);+ const clearLongPress = React.useCallback(() => {+ window.clearTimeout(timer.current);+ timer.current = undefined;+ start.current = undefined;+ }, []);+ React.useEffect(() => clearLongPress, [clearLongPress]);+ const openActions = (+ anchor: HTMLElement,+ source: "touch" | "contextmenu",+ ) => {+ clearLongPress();+ window.getSelection()?.removeAllRanges();+ onOpenActions(anchor, source);+ };+ const isInteractiveTarget = (target: EventTarget | null) =>+ target instanceof Element && Boolean(target.closest("a, button"));+ return (+ <Box+ component="article"+ id={`comment-${comment.commentId}`}+ data-comment-id={comment.commentId}+ data-comment-highlighted={highlighted || undefined}+ tabIndex={canOpenActions ? 0 : undefined}+ aria-label={`Comment by ${comment.author ? firstNameFrom(comment.author.fullName) || `@${comment.author.username}` : "deleted account"}`}+ aria-haspopup={canOpenActions ? "menu" : undefined}+ onContextMenu={(event) => {+ if (!canOpenActions || isInteractiveTarget(event.target))+ return;+ event.preventDefault();+ event.stopPropagation();+ openActions(event.currentTarget, "contextmenu");+ }}+ onKeyDown={(event) => {+ if (!canOpenActions || isInteractiveTarget(event.target))+ return;+ if (+ event.key == "ContextMenu" ||+ (event.shiftKey && event.key == "F10") ||+ event.key == "Enter" ||+ event.key == " "+ ) {+ event.preventDefault();+ openActions(event.currentTarget, "contextmenu");+ }+ }}+ onPointerDown={(event) => {+ clearLongPress();+ didOpen.current = false;+ if (+ !canOpenActions ||+ event.button != 0 ||+ isInteractiveTarget(event.target)+ )+ return;+ start.current = {+ pointerId: event.pointerId,+ x: event.clientX,+ y: event.clientY,+ };+ const anchor = event.currentTarget;+ anchor.setPointerCapture(event.pointerId);+ timer.current = window.setTimeout(() => {+ didOpen.current = true;+ openActions(anchor, "touch");+ }, 520);+ }}+ onPointerMove={(event) => {+ if (start.current?.pointerId != event.pointerId) return;+ if (+ Math.hypot(+ event.clientX - start.current.x,+ event.clientY - start.current.y,+ ) > 10+ )+ clearLongPress();+ }}+ onPointerUp={(event) => {+ clearLongPress();+ if (didOpen.current) {+ event.preventDefault();+ event.stopPropagation();+ }+ }}+ onPointerCancel={clearLongPress}+ onTouchEnd={(event) => {+ if (!didOpen.current) return;+ if (event.cancelable) event.preventDefault();+ event.stopPropagation();+ }}+ onClickCapture={(event) => {+ if (!didOpen.current) return;+ event.preventDefault();+ event.stopPropagation();+ didOpen.current = false;+ }}+ sx={{+ bgcolor: highlighted+ ? spaceControlBackgroundHover+ : "transparent",+ transition: "background-color 400ms ease-out",+ position: "relative",+ py: 0.5,+ px: 2,+ flexShrink: 0,+ cursor: canOpenActions ? "context-menu" : "default",+ touchAction: "pan-y",+ userSelect: "none",+ WebkitTouchCallout: "none",+ WebkitUserSelect: "none",+ "&:focus-visible": {+ outline: "2px solid #08C225",+ outlineOffset: 2,+ },+ "@media (prefers-reduced-motion: reduce)": {+ transition: "none",+ },+ }}+ >+ <Box+ sx={{+ position: "relative",+ display: "grid",+ gridTemplateColumns:+ "minmax(0, 1fr) minmax(80px, max-content)",+ columnGap: 1.5,+ pl: 4.5,+ ml: comment.parentId ? 4.5 : 0,+ }}+ >+ <Box+ sx={{+ display: "flex",+ gridColumn: 1,+ alignItems: "baseline",+ flexWrap: "wrap",+ columnGap: 1,+ rowGap: 0.25,+ lineHeight: "18px",+ mt: "-2px",+ }}+ >+ {comment.author ? (+ <CommentIdentity+ actor={comment.author}+ viewer={viewer}+ inline+ />+ ) : (+ <Box+ component="span"+ sx={{+ fontSize: 13,+ fontWeight: 600,+ color: spaceText,+ }}+ >+ Deleted account+ </Box>+ )}+ <Box+ component="time"+ dateTime={comment.createdAt}+ sx={{+ color: spaceTextMuted,+ fontSize: 11,+ fontWeight: 400,+ whiteSpace: "nowrap",+ }}+ >+ {formatSpaceDate(Date.parse(comment.createdAt)).replace(+ / ago$/,+ "",+ )}+ </Box>+ </Box>+ <Box+ sx={{+ gridColumn: 1,+ whiteSpace: "pre-wrap",+ overflowWrap: "anywhere",+ fontSize: 13,+ fontWeight: 400,+ lineHeight: "20px",+ color: spaceText,+ }}+ >+ {recipient?.author && !recipient.deleted && (+ <Box component="span" sx={{ color: spaceTextMuted }}>+ {`@${recipient.author.username} `}+ </Box>+ )}+ {comment.text ?? "Comment unavailable"}+ </Box>+ {hasReactions && (+ <Box+ component="button"+ type="button"+ aria-label={`View ${comment.reactions.length} ${comment.reactions.length == 1 ? "reaction" : "reactions"}`}+ onClick={onOpenReactions}+ sx={{+ ...textActionSx,+ "--reaction-stack-background": spaceSurface,+ alignItems: "center",+ bgcolor: "var(--reaction-stack-background)",+ borderRadius: "999px",+ boxSizing: "border-box",+ display: "flex",+ gap: "1px",+ justifyContent: "center",+ gridColumn: 2,+ gridRow: 2,+ alignSelf: "start",+ justifySelf: "end",+ minHeight: 28,+ minWidth: 28,+ my: "-4px",+ px: "5px",+ width: "max-content",+ "&:hover": {+ "--reaction-stack-background": "#383838",+ color: spaceText,+ },+ "&:active": {+ "--reaction-stack-background": "#484848",+ },+ }}+ >+ {topReactions.map((emoji, index) => (+ <Box+ component="span"+ key={`${emoji}-${index}`}+ aria-hidden+ sx={{+ bgcolor: "inherit",+ borderRadius: "50%",+ boxShadow:+ "0 0 0 1px var(--reaction-stack-background)",+ display: "grid",+ flexShrink: 0,+ fontSize: 14,+ height: 16,+ lineHeight: "16px",+ placeItems: "center",+ position: "relative",+ width: 16,+ zIndex: topReactions.length - index,+ }}+ >+ {emoji}+ </Box>+ ))}+ <Box+ component="span"+ aria-hidden+ sx={{+ color: spaceTextMuted,+ fontSize: 12,+ fontVariantNumeric: "tabular-nums",+ lineHeight: "16px",+ ml: "4px",+ whiteSpace: "nowrap",+ }}+ >+ {comment.reactions.length}+ </Box>+ </Box>+ )}+ </Box>+ </Box>+ );+};++export const PostComments: React.FC<{+ autoFocus?: boolean;+ targetCommentId?: string;+ viewer: string;+ postId: number;+ owner: string;+ draft: CommentDraft;+ setDraft: React.Dispatch<React.SetStateAction<CommentDraft>>;+ onClose: () => void;+}> = ({+ autoFocus,+ targetCommentId,+ viewer,+ postId,+ owner,+ draft,+ setDraft,+ onClose,+}) => {+ const prefersReducedMotion = useMediaQuery(+ "(prefers-reduced-motion: reduce)",+ );+ const [comments, setComments] = React.useState<SpaceComment[]>([]);+ const threads = commentThreads(comments);+ const [loading, setLoading] = React.useState(true);+ const [error, setError] = React.useState<string>();+ const [open, setOpen] = React.useState(true);+ const [entered, setEntered] = React.useState(false);+ const [highlightedCommentId, setHighlightedCommentId] =+ React.useState<string>();+ const handledTarget = React.useRef<string>(undefined);+ const submittedCommentId = React.useRef<string>(undefined);+ const list = React.useRef<HTMLDivElement>(null);+ const acknowledged = React.useRef(new Set<string>());+ const [action, setAction] = React.useState<+ | {+ type: "menu";+ commentId: string;+ anchor: HTMLElement;+ open: boolean;+ }+ | { type: "react" | "reactions"; commentId: string }+ >();+ const ignoreMouseAwayUntil = React.useRef(0);+ const dragStart = React.useRef<number | undefined>(undefined);+ const [isDragging, setIsDragging] = React.useState(false);+ const [dragOffset, setDragOffset] = React.useState(0);+ const dragged = React.useRef(false);+ const { replyTarget } = draft;+ const reply = comments.find(+ (comment) =>+ replyTarget?.status == "selected" &&+ comment.commentId == replyTarget.commentId,+ );+ const [mutating, setMutating] = React.useState(false);+ const busy = mutating || Boolean(draft.sending);+ const selectedComment = comments.find(+ (comment) => comment.commentId == action?.commentId && !comment.deleted,+ );+ const reactionList =+ action?.type == "reactions" ? selectedComment : undefined;+ const generation = React.useRef(0);+ const input = React.useRef<HTMLTextAreaElement>(null);+ useBrowserBackClose({+ open,+ onClose: () => setOpen(false),+ stateKey: "space-post-comments",+ });+ const refresh = React.useCallback(async () => {+ const current = ++generation.current;+ try {+ const items = await loadCurrentComments(viewer, owner, postId);+ if (current != generation.current) return;+ setComments(items);+ setError(undefined);+ setDraft((value) => ({+ ...value,+ replyTarget: validateCommentReplyTarget(+ value.replyTarget,+ items,+ ),+ }));+ } catch {+ if (current != generation.current) return;+ setComments([]);+ setAction(undefined);+ setError(+ "Discussion unavailable. Access may have changed or the post may have been deleted.",+ );+ } finally {+ if (current == generation.current) setLoading(false);+ }+ }, [viewer, owner, postId, setDraft]);+ React.useEffect(() => {+ if (draft.sending) return;+ const requestGeneration = generation;+ void refresh();+ return () => {+ requestGeneration.current++;+ };+ }, [refresh, draft.sending]);+ React.useLayoutEffect(() => {+ if (+ loading ||+ !targetCommentId ||+ handledTarget.current == targetCommentId+ )+ return;+ const container = list.current;+ const target = Array.from(+ container?.querySelectorAll<HTMLElement>("[data-comment-id]") ?? [],+ ).find((row) => row.dataset.commentId == targetCommentId);+ handledTarget.current = targetCommentId;+ if (!container || !target) return;+ const bounds = target.getBoundingClientRect();+ container.scrollTo({+ top:+ container.scrollTop ++ bounds.top -+ container.getBoundingClientRect().top -+ Math.max(12, (container.clientHeight - bounds.height) / 2),+ behavior: "instant",+ });+ setHighlightedCommentId(targetCommentId);+ }, [comments, loading, targetCommentId]);+ React.useLayoutEffect(() => {+ const container = list.current;+ if (+ !container ||+ !open ||+ reactionList ||+ !comments.some(+ (comment) => comment.commentId == submittedCommentId.current,+ )+ )+ return;+ submittedCommentId.current = undefined;+ container.scrollTo({+ top: container.scrollHeight,+ behavior: prefersReducedMotion ? "instant" : "smooth",+ });+ }, [comments, open, prefersReducedMotion, reactionList]);+ React.useEffect(() => {+ if (!highlightedCommentId) return;+ const timer = window.setTimeout(+ () => setHighlightedCommentId(undefined),+ 1800,+ );+ return () => window.clearTimeout(timer);+ }, [highlightedCommentId]);+ React.useEffect(() => {+ const container = list.current;+ if (!container || !entered || loading || !open || action) return;+ const notifications = new Map(+ comments+ .filter(+ (comment) => !comment.deleted && comment.text !== undefined,+ )+ .map((comment) => [+ comment.commentId,+ comment.unreadNotificationIds,+ ]),+ );+ const acknowledge = async (ids: string[]) => {+ for (let offset = 0; offset < ids.length; offset += 100) {+ const batch = ids+ .slice(offset, offset + 100)+ .filter((id) => !acknowledged.current.has(id));+ if (batch.length == 0) continue;+ batch.forEach((id) => acknowledged.current.add(id));+ try {+ await markCurrentNotificationItemsRead(viewer, batch);+ } catch (error) {+ batch.forEach((id) => acknowledged.current.delete(id));+ log.warn(+ "Failed to acknowledge comment notifications",+ error,+ );+ }+ }+ };+ let observer: IntersectionObserver | undefined;+ const observe = () => {+ observer?.disconnect();+ if (+ document.visibilityState != "visible" ||+ container.clientHeight == 0+ )+ return;+ const rows = Array.from(+ container.querySelectorAll<HTMLElement>("[data-comment-id]"),+ );+ const threshold = [+ ...new Set(+ rows.map((row) =>+ Math.min(+ 0.5,+ container.clientHeight /+ (2 * row.getBoundingClientRect().height),+ ),+ ),+ ),+ ];+ observer = new IntersectionObserver(+ (entries) => {+ if (+ document.visibilityState != "visible" ||+ container.clientHeight == 0+ )+ return;+ const ids = entries+ .filter(+ (entry) =>+ entry.isIntersecting &&+ entry.intersectionRect.height >=+ Math.min(+ entry.boundingClientRect.height,+ container.clientHeight,+ ) /+ 2,+ )+ .flatMap(+ (entry) =>+ notifications.get(+ (entry.target as HTMLElement).dataset+ .commentId!,+ ) ?? [],+ );+ if (ids.length > 0) void acknowledge(ids);+ },+ { root: container, threshold },+ );+ rows.forEach((row) => observer!.observe(row));+ };+ observe();+ const resize = new ResizeObserver(observe);+ resize.observe(container);+ document.addEventListener("visibilitychange", observe);+ return () => {+ observer?.disconnect();+ resize.disconnect();+ document.removeEventListener("visibilitychange", observe);+ };+ }, [action, comments, entered, loading, open, viewer]);+ const mutate = async (action: () => Promise<void>) => {+ setMutating(true);+ try {+ await action();+ await refresh();+ } catch {+ await refresh();+ setError("Couldn't save your change. Refresh and try again.");+ } finally {+ setMutating(false);+ }+ };+ const react = (comment: SpaceComment, emoji: string) => {+ void mutate(() =>+ setCurrentCommentReaction(+ viewer,+ owner,+ postId,+ comment.commentId,+ comment.reactions.some(+ (item) => item.isOwn && item.emoji == emoji,+ )+ ? undefined+ : emoji,+ ),+ );+ };+ const closeActions = () =>+ setAction((current) =>+ current?.type == "menu" ? { ...current, open: false } : current,+ );+ const renderComment = (comment: SpaceComment) => (+ <CommentRow+ key={comment.commentId}+ comment={comment}+ recipient={comments.find(+ (item) => item.commentId == comment.replyToId,+ )}+ viewer={viewer}+ highlighted={highlightedCommentId == comment.commentId}+ disabled={busy}+ onOpenActions={(anchor, source) => {+ ignoreMouseAwayUntil.current =+ source == "touch" ? Date.now() + 900 : 0;+ setAction({+ type: "menu",+ commentId: comment.commentId,+ anchor,+ open: true,+ });+ }}+ onOpenReactions={() =>+ setAction({ type: "reactions", commentId: comment.commentId })+ }+ />+ );+ return (+ <Dialog+ open={open}+ onClose={() => setOpen(false)}+ maxWidth={false}+ aria-label={reactionList ? "Reactions" : "Comments"}+ slots={+ prefersReducedMotion+ ? undefined+ : { transition: SpaceBottomSheetTransition }+ }+ transitionDuration={prefersReducedMotion ? 0 : undefined}+ sx={{+ "--space-dialog-backdrop": "rgba(0 0 0 / 0.64)",+ "& .MuiDialog-container": {+ alignItems: "flex-end",+ pb: isSpaceIOS() ? "var(--space-keyboard-inset, 0px)" : 0,+ },+ }}+ slotProps={{+ paper: {+ style: {+ translate: `0 ${dragOffset}px`,+ transition:+ isDragging || prefersReducedMotion+ ? "none"+ : "translate 160ms ease-out",+ },+ sx: {+ bgcolor: spaceDialogBackground,+ color: spaceText,+ borderRadius: "28px 28px 0 0",+ boxShadow: "none",+ boxSizing: "border-box",+ display: "flex",+ flexDirection: "column",+ height: "min(72dvh, 640px)",+ m: 0,+ maxHeight: isSpaceIOS()+ ? "calc(100dvh - var(--space-keyboard-inset, 0px) - env(safe-area-inset-top) - 16px)"+ : "calc(100dvh - env(safe-area-inset-top) - 16px)",+ maxWidth: { xs: "none", sm: 480 },+ overflow: "hidden",+ width: "100%",+ fontFamily: '"Inter Variable", Inter, sans-serif',+ },+ },+ transition: {+ onEntered: () => setEntered(true),+ onExited: onClose,+ },+ }}+ >+ <Box+ component="button"+ type="button"+ aria-label="Close comments"+ onClick={(event) => {+ if (event.detail == 0 || !dragged.current) setOpen(false);+ dragged.current = false;+ }}+ onPointerDown={(event) => {+ if (event.button != 0) return;+ dragStart.current = event.clientY;+ dragged.current = false;+ setIsDragging(true);+ event.currentTarget.setPointerCapture(event.pointerId);+ }}+ onPointerMove={(event) => {+ if (dragStart.current != undefined) {+ if (Math.abs(event.clientY - dragStart.current) > 4)+ dragged.current = true;+ setDragOffset(+ Math.max(0, event.clientY - dragStart.current),+ );+ }+ }}+ onPointerUp={(event) => {+ if (dragStart.current == undefined) return;+ const distance = event.clientY - dragStart.current;+ dragStart.current = undefined;+ setIsDragging(false);+ if (distance > 80) setOpen(false);+ else setDragOffset(0);+ }}+ onPointerCancel={() => {+ dragStart.current = undefined;+ dragged.current = true;+ setIsDragging(false);+ setDragOffset(0);+ }}+ sx={{+ ...textActionSx,+ alignItems: "center",+ cursor: isDragging ? "grabbing" : "grab",+ display: "flex",+ justifyContent: "center",+ minHeight: 32,+ flexShrink: 0,+ touchAction: "none",+ width: "100%",+ "&:focus-visible": {+ outline: "2px solid #08C225",+ outlineOffset: -2,+ },+ }}+ >+ <Box+ component="span"+ sx={{+ bgcolor: "#686868",+ borderRadius: "999px",+ height: 4,+ width: 32,+ }}+ />+ </Box>+ <Box+ sx={{+ display: "flex",+ alignItems: "center",+ justifyContent: "center",+ px: 2,+ pb: 2,+ flexShrink: 0,+ position: "relative",+ }}+ >+ {reactionList && (+ <Box+ component="button"+ type="button"+ aria-label="Back to comments"+ onClick={() => setAction(undefined)}+ sx={{+ ...textActionSx,+ position: "absolute",+ left: 16,+ display: "flex",+ alignItems: "center",+ }}+ >+ <HugeiconsIcon+ icon={ArrowLeft02Icon}+ size={20}+ strokeWidth={1.8}+ />+ </Box>+ )}+ <Box+ component="h2"+ sx={{+ fontSize: 16,+ fontWeight: 600,+ lineHeight: "24px",+ m: 0,+ }}+ >+ {reactionList ? "Reactions" : "Comments"}+ </Box>+ </Box>+ <Box+ ref={list}+ sx={{+ py: 1,+ display: "flex",+ flexDirection: "column",+ overflowY: "auto",+ overscrollBehavior: "contain",+ flex: "1 1 auto",+ minHeight: 0,+ }}+ >+ {reactionList ? (+ <>+ {reactionList.reactions.length == 0 && (+ <Box+ role="status"+ sx={{+ alignItems: "center",+ color: spaceTextMuted,+ display: "flex",+ flex: "1 1 auto",+ fontSize: 13,+ justifyContent: "center",+ px: 2,+ py: 3,+ }}+ >+ No reactions yet+ </Box>+ )}+ {groupCommentReactions(reactionList.reactions).map(+ (reaction) => (+ <Box+ key={reaction.actor.id}+ sx={{+ display: "flex",+ alignItems: "center",+ gap: 1.5,+ px: 2,+ py: 1,+ flexShrink: 0,+ }}+ >+ <CommentIdentity+ actor={reaction.actor}+ viewer={viewer}+ />+ <Box+ sx={{+ ml: "auto",+ display: "flex",+ alignItems: "center",+ gap: 1.5,+ flexShrink: 0,+ }}+ >+ {(reaction.isOwn ||+ viewer == owner) && (+ <Box+ component="button"+ type="button"+ disabled={busy}+ sx={{+ ...textActionSx,+ bgcolor: "#383838",+ borderRadius: "999px",+ color: spaceText,+ minHeight: 28,+ px: 1.5,+ "&:hover": {+ bgcolor: "#484848",+ },+ "&:active": {+ bgcolor: "#505050",+ },+ }}+ onClick={() =>+ void mutate(() =>+ removeCurrentCommentReaction(+ viewer,+ postId,+ reactionList.commentId,+ reaction.actor+ .spaceId!,+ ),+ )+ }+ >+ Remove+ </Box>+ )}+ <Box sx={{ fontSize: 18 }}>+ {reaction.emoji}+ </Box>+ </Box>+ </Box>+ ),+ )}+ </>+ ) : (+ <>+ {!loading &&+ !error &&+ targetCommentId &&+ !comments.some(+ (comment) =>+ comment.commentId == targetCommentId,+ ) && (+ <Box+ role="status"+ sx={{+ px: 2,+ py: 2,+ color: spaceTextMuted,+ fontSize: 13,+ }}+ >+ This comment is no longer available.+ </Box>+ )}+ {loading && (+ <Box+ sx={{+ alignItems: "center",+ display: "flex",+ flex: "1 1 auto",+ justifyContent: "center",+ py: 3,+ }}+ >+ <CircularProgress+ size={20}+ sx={{ color: spaceTextMuted }}+ />+ </Box>+ )}+ {!loading && !error && threads.length == 0 && (+ <Box+ sx={{+ display: "flex",+ flexDirection: "column",+ flex: "1 1 auto",+ justifyContent: "center",+ gap: 0.75,+ px: 2,+ py: 3,+ textAlign: "center",+ }}+ >+ <Box+ component="p"+ sx={{ m: 0, fontSize: 15, fontWeight: 600 }}+ >+ No comments yet+ </Box>+ <Box+ component="p"+ sx={{+ m: 0,+ color: spaceTextMuted,+ fontSize: 13,+ }}+ >+ Be the first to comment+ </Box>+ </Box>+ )}+ {threads.map(({ comment, replies }, index) => (+ <Box+ key={comment.commentId}+ sx={{+ flexShrink: 0,+ py: 1,+ mt: index > 0 ? 1 : 0,+ }}+ >+ {renderComment(comment)}+ {replies.length > 0 && (+ <Box+ sx={{+ display: "flex",+ flexDirection: "column",+ gap: 1,+ mt: 1,+ }}+ >+ {replies.map(renderComment)}+ </Box>+ )}+ </Box>+ ))}+ {error && (+ <Box+ role="alert"+ sx={{+ px: 2,+ py: 2,+ color: spaceTextMuted,+ fontSize: 13,+ }}+ >+ {error}{" "}+ <Box+ component="button"+ type="button"+ onClick={() => void refresh()}+ sx={textActionSx}+ >+ Refresh+ </Box>+ </Box>+ )}+ </>+ )}+ </Box>+ <Box+ sx={{+ display: reactionList ? "none" : "grid",+ gap: "8px",+ px: 2,+ pt: 2,+ pb: "max(16px, env(safe-area-inset-bottom))",+ flexShrink: 0,+ }}+ >+ {replyTarget && (+ <ReplyComposerPreview+ tone="neutral"+ name={+ replyTarget.status == "unavailable"+ ? "Comment unavailable"+ : reply?.author?.spaceId == viewer+ ? "You"+ : reply?.author+ ? firstNameFrom(reply.author.fullName) ||+ `@${reply.author.username}`+ : reply+ ? "Deleted account"+ : "Replyingโฆ"+ }+ text={+ replyTarget.status == "unavailable"+ ? "This comment or its thread is no longer available."+ : loading && !reply+ ? "Loading commentโฆ"+ : (reply?.text ?? "Comment unavailable")+ }+ cancelLabel={+ replyTarget.status == "unavailable"+ ? "Comment instead"+ : "Cancel reply"+ }+ onCancel={() => {+ flushSync(() =>+ setDraft((value) => ({+ ...value,+ replyTarget: undefined,+ })),+ );+ input.current?.focus({ preventScroll: true });+ }}+ />+ )}+ <SpaceCommentComposer+ autoFocus={autoFocus}+ inputRef={input}+ text={draft.text}+ onTextChange={(text) =>+ setDraft((value) => ({ ...value, text }))+ }+ disabled={+ busy ||+ Boolean(error) ||+ replyTarget?.status == "unavailable"+ }+ sendDisabled={loading}+ placeholder={replyTarget ? "Replyโฆ" : "Add a commentโฆ"}+ onSend={async (text) => {+ setDraft((value) => ({ ...value, sending: true }));+ try {+ const commentId = crypto.randomUUID();+ await createCurrentComment(+ viewer,+ owner,+ postId,+ commentId,+ replyTarget?.status == "selected"+ ? replyTarget.commentId+ : undefined,+ text,+ );+ submittedCommentId.current =+ replyTarget?.status == "selected"+ ? undefined+ : commentId;+ setDraft({ text: "", sending: true });+ } finally {+ setDraft((value) => ({ ...value, sending: false }));+ }+ }}+ />+ </Box>+ {action?.type == "react" && selectedComment && (+ <MessageReactionPicker+ label="React to comment"+ selected={+ selectedComment.reactions.find((item) => item.isOwn)+ ?.emoji+ }+ onClose={() => setAction(undefined)}+ onSelect={(emoji) => react(selectedComment, emoji)}+ />+ )}+ <Popper+ anchorEl={action?.type == "menu" ? action.anchor : undefined}+ open={+ open &&+ action?.type == "menu" &&+ action.open &&+ Boolean(selectedComment)+ }+ placement="bottom-start"+ disablePortal+ transition+ modifiers={[+ { name: "offset", options: { offset: [0, 8] } },+ {+ name: "preventOverflow",+ options: {+ altAxis: true,+ boundary: list.current,+ padding: 8,+ },+ },+ {+ name: "flip",+ options: {+ boundary: list.current,+ padding: 8,+ fallbackPlacements: ["top-start"],+ flipVariations: false,+ },+ },+ ]}+ sx={{ outline: 0, zIndex: 1500 }}+ >+ {({ TransitionProps, placement }) => (+ <ClickAwayListener+ mouseEvent="onMouseDown"+ touchEvent="onTouchStart"+ onClickAway={(event) => {+ if (+ event instanceof MouseEvent &&+ Date.now() < ignoreMouseAwayUntil.current+ )+ return;+ closeActions();+ }}+ >+ <Grow+ {...(TransitionProps ?? {})}+ easing={{+ enter: "cubic-bezier(0.18, 0.9, 0.3, 1.18)",+ exit: "ease-in",+ }}+ style={{+ transformOrigin: `left ${placement.startsWith("top") ? "bottom" : "top"}`,+ }}+ timeout={+ prefersReducedMotion+ ? 0+ : messageActionsTransitionDuration+ }+ onExited={() => {+ TransitionProps?.onExited();+ setAction((current) =>+ current?.type == "menu" && !current.open+ ? undefined+ : current,+ );+ }}+ >+ <Box+ inert={!TransitionProps?.in || busy}+ onKeyDown={(+ event: React.KeyboardEvent<HTMLElement>,+ ) => {+ if (event.key != "Escape") return;+ event.preventDefault();+ event.stopPropagation();+ closeActions();+ if (action?.type == "menu")+ action.anchor.focus({+ preventScroll: true,+ });+ }}+ sx={{+ WebkitTapHighlightColor: "transparent",+ display: "flex",+ flexDirection: "column",+ gap: "8px",+ outline: 0,+ "& > [role=group], & > [role=menu]": {+ bgcolor: "#383838",+ boxShadow: "none",+ },+ "& > [role=group] > button": {+ "&:hover, &[aria-pressed=true]": {+ bgcolor: "#505050",+ },+ "&:active": { bgcolor: "#606060" },+ },+ }}+ >+ {selectedComment?.text !== undefined && (+ <MessageQuickReactions+ label="React to comment"+ selected={+ selectedComment.reactions.find(+ (item) => item.isOwn,+ )?.emoji+ }+ onSelect={(emoji) => {+ closeActions();+ react(selectedComment, emoji);+ }}+ onMore={() =>+ setAction({+ type: "react",+ commentId:+ selectedComment.commentId,+ })+ }+ />+ )}+ <MessageActionMenuList+ aria-label="Comment actions"+ onKeyDown={(event) => {+ if (event.key != "Tab") return;+ event.preventDefault();+ closeActions();+ if (action?.type == "menu")+ action.anchor.focus({+ preventScroll: true,+ });+ }}+ autoFocus={+ selectedComment?.text === undefined+ }+ variant="menu"+ >+ {selectedComment && (+ <MessageActionMenuItem+ icon={<ReplyIcon />}+ label="Reply"+ onClick={() => {+ flushSync(() => {+ closeActions();+ setDraft((value) => ({+ ...value,+ replyTarget: {+ status: "selected",+ commentId:+ selectedComment.commentId,+ },+ }));+ });+ input.current?.focus({+ preventScroll: true,+ });+ }}+ />+ )}+ {selectedComment?.text !== undefined && (+ <MessageActionMenuItem+ icon={<CopyIcon />}+ label="Copy"+ onClick={() => {+ closeActions();+ void navigator.clipboard+ .writeText(+ selectedComment.text!,+ )+ .catch((error: unknown) =>+ log.error(+ "Failed to copy comment",+ error,+ ),+ );+ }}+ />+ )}+ {selectedComment?.canDelete && (+ <MessageActionMenuItem+ icon={<DeleteIcon />}+ label="Delete"+ tone="danger"+ onClick={() => {+ closeActions();+ void mutate(() =>+ deleteCurrentComment(+ viewer,+ postId,+ selectedComment.commentId,+ ),+ );+ }}+ />+ )}+ </MessageActionMenuList>+ </Box>+ </Grow>+ </ClickAwayListener>+ )}+ </Popper>+ </Dialog>+ );+};diff --git a/web/apps/space/src/components/PostReplyControls.tsx b/web/apps/space/src/components/PostReplyControls.tsxindex f4338be02b..816b7fd391 100644--- a/web/apps/space/src/components/PostReplyControls.tsx+++ b/web/apps/space/src/components/PostReplyControls.tsx@@ -5,7 +5,7 @@ import {Tick02Icon,} from "@hugeicons/core-free-icons";import { HugeiconsIcon } from "@hugeicons/react";-import { Box } from "@mui/material";+import { Box, Collapse, useMediaQuery } from "@mui/material";import { keyframes } from "@mui/material/styles";import type { SpaceActionPhase } from "components/ActionFeedback";import {@@ -21,12 +21,11 @@ import {spaceControlBackgroundHover,spaceMenuHover,spaceText,- spaceTextMuted,} from "styles/colors";const green = "#08C225";const textBase = spaceText;-const textSecondary = spaceTextMuted;+const textSecondary = "#C4C4C8";const controlBackground = spaceControlBackground;const controlBackgroundHover = spaceControlBackgroundHover;const controlBackgroundActive = spaceMenuHover;@@ -54,8 +53,58 @@ const viewerActionButtonSx = {"&:hover": { bgcolor: controlBackgroundHover },};+export const SpacePostInputButton: React.FC<{+ backgroundColor?: string;+ hoverBackgroundColor?: string;+ disabled?: boolean;+ label: string;+ placeholder: string;+ onClick: () => void;+}> = ({+ backgroundColor = controlBackground,+ hoverBackgroundColor = controlBackgroundHover,+ disabled,+ label,+ placeholder,+ onClick,+}) => (+ <Box+ component="button"+ type="button"+ aria-label={label}+ title={label}+ disabled={disabled}+ onClick={onClick}+ sx={{+ ...viewerActionButtonSx,+ bgcolor: backgroundColor,+ borderRadius: "24px",+ color: textSecondary,+ display: "block",+ flex: "1 1 auto",+ font: "inherit",+ fontSize: 14,+ fontWeight: 400,+ lineHeight: "20px",+ minWidth: 0,+ overflow: "hidden",+ px: `${replyInputPaddingLeft}px`,+ textAlign: "left",+ textOverflow: "ellipsis",+ whiteSpace: "nowrap",+ width: "auto",+ "&:disabled": { cursor: "default" },+ "&:hover": { bgcolor: hoverBackgroundColor },+ }}+ >+ {placeholder}+ </Box>+);+interface SpacePostReplyControlsProps {+ ref?: React.Ref<HTMLDivElement>;canSendReply: boolean;+ commentsButton?: React.ReactNode;disabled?: boolean;isLikePending?: boolean;isReplyMode: boolean;@@ -63,6 +112,7 @@ interface SpacePostReplyControlsProps {likePopID: number;likeToggleID: number;postKey: string;+ onBlur?: React.FocusEventHandler<HTMLDivElement>;onLike: () => void;onSendReply: () => void;replyActionPhase: SpaceActionPhase | null;@@ -71,7 +121,9 @@ interface SpacePostReplyControlsProps {}export const SpacePostReplyControls: React.FC<SpacePostReplyControlsProps> = ({+ ref,canSendReply,+ commentsButton,disabled = false,isLikePending = false,isReplyMode,@@ -79,6 +131,7 @@ export const SpacePostReplyControls: React.FC<SpacePostReplyControlsProps> = ({likePopID,likeToggleID,postKey,+ onBlur,onLike,onSendReply,replyActionPhase,@@ -91,20 +144,37 @@ export const SpacePostReplyControls: React.FC<SpacePostReplyControlsProps> = ({const replyInputRef = externalReplyInputRef ?? internalReplyInputRef;const isLikePopping = !isReplyMode && liked && likePopID > 0;const isSendActive = isReplyMode && canSendReply;+ const prefersReducedMotion = useMediaQuery(+ "(prefers-reduced-motion: reduce)",+ );React.useLayoutEffect(() => {const input = replyInputRef.current;if (!input) return;- input.style.height = `${spacePostReplyInputMinHeight}px`;- input.style.height = `${Math.max(spacePostReplyInputMinHeight, Math.min(input.scrollHeight, captionInputMaxHeight))}px`;- input.style.overflowY =- input.scrollHeight > captionInputMaxHeight ? "auto" : "hidden";- }, [replyInputRef, replyInputProps?.value]);+ const resize = () => {+ input.style.height = `${spacePostReplyInputMinHeight}px`;+ input.style.overflowY = "hidden";+ if (!isReplyMode) return;+ input.style.height = `${Math.max(spacePostReplyInputMinHeight, Math.min(input.scrollHeight, captionInputMaxHeight))}px`;+ input.style.overflowY =+ input.scrollHeight > captionInputMaxHeight ? "auto" : "hidden";+ };+ resize();+ let width = input.clientWidth;+ const observer = new ResizeObserver(() => {+ if (input.clientWidth == width) return;+ width = input.clientWidth;+ resize();+ });+ observer.observe(input);+ return () => observer.disconnect();+ }, [isReplyMode, replyInputRef, replyInputProps?.value]);return (<Box+ ref={ref}+ onBlur={onBlur}sx={{alignItems: "flex-end",display: "flex",- gap: "8px",justifyContent: "flex-end",width: "100%",}}@@ -113,25 +183,26 @@ export const SpacePostReplyControls: React.FC<SpacePostReplyControlsProps> = ({<Boxref={replyInputRef}component="textarea"- aria-label="Reply to photo"+ aria-label="Reply privately"disabled={disabled || replyActionPhase != null}- placeholder="Reply..."+ placeholder="Send a messageโฆ"rows={1}{...replyInputProps}sx={{bgcolor: controlBackground,border: 0,- borderRadius: "16px",+ borderRadius: "24px",boxSizing: "border-box",color: textBase,flex: "1 1 auto",fontFamily: '"Inter Variable", Inter, sans-serif',fontSize: 14,- fontWeight: 500,+ fontWeight: 400,lineHeight: "20px",maxHeight: captionInputMaxHeight,minHeight: spacePostReplyInputMinHeight,minWidth: 0,+ mr: 1,outline: 0,overflow: "hidden",pb: `${replyInputPadding}px`,@@ -139,12 +210,30 @@ export const SpacePostReplyControls: React.FC<SpacePostReplyControlsProps> = ({pr: `${replyInputPadding}px`,pt: `${replyInputPadding}px`,resize: "none",+ textOverflow: isReplyMode ? "clip" : "ellipsis",+ whiteSpace: isReplyMode ? "pre-wrap" : "nowrap","&::placeholder": { color: textSecondary },"&:disabled": { opacity: 0.74 },"&:focus": { bgcolor: controlBackgroundHover },}}/>)}+ {commentsButton && (+ <Collapse+ in={!isReplyMode}+ inert={isReplyMode}+ orientation="horizontal"+ timeout={prefersReducedMotion ? 0 : 220}+ easing="cubic-bezier(0.22, 1, 0.36, 1)"+ sx={{+ flexShrink: 0,+ opacity: isReplyMode ? 0 : 1,+ transitionProperty: "width, opacity",+ }}+ >+ <Box sx={{ pr: 1 }}>{commentsButton}</Box>+ </Collapse>+ )}<Boxsx={{flexShrink: 0,diff --git a/web/apps/space/src/components/PostTile.tsx b/web/apps/space/src/components/PostTile.tsxindex afd02da1af..9a7a358ff9 100644--- a/web/apps/space/src/components/PostTile.tsx+++ b/web/apps/space/src/components/PostTile.tsx@@ -19,6 +19,7 @@ const green = "#08C225";export interface SpacePostTileItem {avatarUrl?: string | null;caption?: string;+ commentCount?: number;friendID?: string;height?: number;id: string;diff --git a/web/apps/space/src/components/ReplyComposerPreview.tsx b/web/apps/space/src/components/ReplyComposerPreview.tsxnew file mode 100644index 0000000000..3e3f9ed477--- /dev/null+++ b/web/apps/space/src/components/ReplyComposerPreview.tsx@@ -0,0 +1,121 @@+import { Cancel01Icon } from "@hugeicons/core-free-icons";+import { HugeiconsIcon } from "@hugeicons/react";+import { Box } from "@mui/material";+import React from "react";+import {+ spaceControlBackgroundHover,+ spaceSurface,+ spaceText,+ spaceTextMuted,+} from "styles/colors";+import { spaceTouchTargetSize } from "styles/touch-targets";++const green = "#08C225";++export const ReplyComposerPreview: React.FC<{+ name: string;+ text: string;+ tone?: "accent" | "neutral";+ cancelLabel?: string;+ onCancel: () => void;+}> = ({+ name,+ text,+ tone = "accent",+ cancelLabel = "Cancel reply",+ onCancel,+}) => {+ const neutral = tone == "neutral";+ const lines = text.split("\n");+ const firstLine = lines[0] ?? text;+ const preview =+ firstLine.length > 100+ ? `${firstLine.slice(0, 100)}...`+ : lines.length > 1+ ? `${firstLine}...`+ : firstLine;+ return (+ <Box+ sx={{+ bgcolor: neutral ? spaceControlBackgroundHover : spaceSurface,+ borderLeft: `3px solid ${neutral ? "#686868" : green}`,+ borderRadius: "12px",+ boxSizing: "border-box",+ display: "grid",+ gridTemplateColumns: "minmax(0, 1fr)",+ maxWidth: "100%",+ overflow: "hidden",+ p: "9px 40px 9px 12px",+ position: "relative",+ width: "100%",+ }}+ >+ <Box sx={{ maxWidth: "100%", minWidth: 0, overflow: "hidden" }}>+ <Box+ sx={{+ color: neutral ? spaceText : spaceTextMuted,+ fontFamily: '"Inter Variable", Inter, sans-serif',+ fontSize: 12,+ fontWeight: 650,+ lineHeight: "16px",+ overflow: "hidden",+ textOverflow: "ellipsis",+ whiteSpace: "nowrap",+ }}+ >+ {name}+ </Box>+ <Box+ sx={{+ color: neutral ? spaceTextMuted : spaceText,+ fontFamily: '"Inter Variable", Inter, sans-serif',+ fontSize: 13,+ fontWeight: neutral ? 400 : 600,+ lineHeight: "18px",+ maxWidth: "100%",+ overflow: "hidden",+ overflowWrap: "anywhere",+ textOverflow: "ellipsis",+ whiteSpace: "nowrap",+ }}+ >+ {preview}+ </Box>+ </Box>+ <Box+ component="button"+ type="button"+ aria-label={cancelLabel}+ onClick={onCancel}+ sx={{+ alignItems: "center",+ bgcolor: "transparent",+ border: 0,+ borderRadius: "50%",+ color: spaceTextMuted,+ cursor: "pointer",+ display: "flex",+ height: spaceTouchTargetSize,+ justifyContent: "center",+ p: 0,+ position: "absolute",+ right: 0,+ top: 0,+ width: spaceTouchTargetSize,+ "&:focus-visible": {+ outline: `2px solid ${green}`,+ outlineOffset: 2,+ },+ "&:hover": { color: spaceText },+ "& svg": { position: "absolute", right: 8, top: 8 },+ }}+ >+ <HugeiconsIcon+ icon={Cancel01Icon}+ size={16}+ strokeWidth={1.8}+ />+ </Box>+ </Box>+ );+};diff --git a/web/apps/space/src/hooks/use-comment-count.ts b/web/apps/space/src/hooks/use-comment-count.tsnew file mode 100644index 0000000000..155936208f--- /dev/null+++ b/web/apps/space/src/hooks/use-comment-count.ts@@ -0,0 +1,16 @@+import { useSyncExternalStore } from "react";+import {+ cachedCommentCount,+ subscribeToCommentCounts,+} from "services/comment-counts";++export const useCommentCount = (+ viewer: string | undefined,+ postId: number | undefined,+ initialCount = 0,+) =>+ useSyncExternalStore(+ subscribeToCommentCounts,+ () => cachedCommentCount(viewer, postId) ?? initialCount,+ () => initialCount,+ );diff --git a/web/apps/space/src/hooks/use-comment-draft.ts b/web/apps/space/src/hooks/use-comment-draft.tsnew file mode 100644index 0000000000..92de5a0011--- /dev/null+++ b/web/apps/space/src/hooks/use-comment-draft.ts@@ -0,0 +1,21 @@+import { useCallback, useState, type SetStateAction } from "react";+import type { CommentDraft } from "utils/comments";++const emptyDraft: CommentDraft = { text: "" };++export const useCommentDraft = (viewer?: string, postId?: number) => {+ const [drafts, setDrafts] = useState<Record<string, CommentDraft>>({});+ const key = `${viewer}:${postId}`;+ const setDraft = useCallback(+ (update: SetStateAction<CommentDraft>) =>+ setDrafts((current) => ({+ ...current,+ [key]:+ typeof update == "function"+ ? update(current[key] ?? emptyDraft)+ : update,+ })),+ [key],+ );+ return [drafts[key] ?? emptyDraft, setDraft] as const;+};diff --git a/web/apps/space/src/pages/app/notifications.tsx b/web/apps/space/src/pages/app/notifications.tsxindex 9acb841acd..7ac5e824d3 100644--- a/web/apps/space/src/pages/app/notifications.tsx+++ b/web/apps/space/src/pages/app/notifications.tsx@@ -1,8 +1,4 @@-import {- ArrowLeft02Icon,- Cancel01Icon,- FavouriteIcon,-} from "@hugeicons/core-free-icons";+import { ArrowLeft02Icon, Cancel01Icon } from "@hugeicons/core-free-icons";import { HugeiconsIcon } from "@hugeicons/react";import { Box } from "@mui/material";import {@@ -49,9 +45,10 @@ import {spaceTextMuted,} from "styles/colors";import { groupSpaceActivities } from "utils/activity-sections";+import { commentNotificationText } from "utils/comments";import { firstNameFrom } from "utils/display";import { isFriendRequestCanceledError } from "utils/friend-errors";-import { spacePostDeletedEvent } from "utils/post-events";+import { notificationGroupKey } from "utils/notifications";import { postQuoteErrorState } from "utils/post-quote";import { useSpaceRouter } from "utils/route-transitions";import { spaceRoutes } from "utils/routes";@@ -95,7 +92,10 @@ const NotificationRow: React.FC<{group: SpaceNotification;isNew: boolean;spaceId: string;- loadPostPreview: (postId: number) => Promise<SpacePostPreview | undefined>;+ loadPostPreview: (+ postId: number,+ postSpaceId?: string,+ ) => Promise<SpacePostPreview | undefined>;onPostSomething: () => void;showPostSomething: boolean;isOpeningPost: boolean;@@ -120,6 +120,7 @@ const NotificationRow: React.FC<{const otherCount = group.actorCount - 1;const isFriendRequest = group.kind == "friend_request";const isPostLike = group.kind == "post_like";+ const isDiscussion = group.kind.startsWith("comment");const backgroundColor = isNew ? spaceSurface : "transparent";const [isRequestPending, setIsRequestPending] = React.useState(false);const [requestError, setRequestError] = React.useState<string>();@@ -146,7 +147,7 @@ const NotificationRow: React.FC<{(entries) => {if (!entries.some((entry) => entry.isIntersecting)) return;observer.disconnect();- void loadPostPreview(postId).then((post) => {+ void loadPostPreview(postId, group.postSpaceId).then((post) => {if (!cancelled) setPreview(post);});},@@ -157,7 +158,7 @@ const NotificationRow: React.FC<{cancelled = true;observer.disconnect();};- }, [group.postId, loadPostPreview]);+ }, [group.postId, group.postSpaceId, loadPostPreview]);return (<Box component="li" sx={{ listStyle: "none" }}>@@ -228,12 +229,15 @@ const NotificationRow: React.FC<{isFriendRequest? undefined: () => {- if (isPostLike)+ if (isPostLike || isDiscussion)void router.push(spaceRoutes.post(- spaceId,+ group.postSpaceId ?? spaceId,group.postId!,- ),+ ) ++ (isDiscussion+ ? `?comments=1&comment=${encodeURIComponent(group.commentId!)}`+ : ""),);elsevoid router.push(@@ -251,9 +255,10 @@ const NotificationRow: React.FC<{cursor: isFriendRequest ? "default" : "pointer",display: "grid",gap: "10px",- gridTemplateColumns: isPostLike- ? "minmax(0, 1fr) 44px"- : "minmax(0, 1fr)",+ gridTemplateColumns:+ isPostLike || isDiscussion+ ? "minmax(0, 1fr) 44px"+ : "minmax(0, 1fr)",minWidth: 0,p: 0,textAlign: "left",@@ -289,47 +294,28 @@ const NotificationRow: React.FC<{}createdAtMs={group.createdAtMs}/>- <Box sx={spaceActivityPreviewSx}>+ <Box+ sx={{+ ...spaceActivityPreviewSx,+ ...(isDiscussion && {+ whiteSpace: "normal",+ overflowWrap: "anywhere",+ }),+ }}+ >{isPostLike? "Liked your post"- : isFriendRequest- ? "Sent you a friend request"- : group.kind == "poke"- ? "Poked you"- : "You're now friends"}+ : isDiscussion+ ? commentNotificationText(group, spaceId)+ : isFriendRequest+ ? "Sent you a friend request"+ : group.kind == "poke"+ ? "Poked you"+ : "You're now friends"}</Box></Box>- {isPostLike && (- <Box- sx={{ position: "relative", width: 44, height: 44 }}- >- <SpacePostPreviewThumbnail post={preview} />- <Box- component="span"- aria-hidden- sx={{- alignItems: "center",- bottom: -5,- display: "inline-flex",- height: 16,- justifyContent: "center",- pointerEvents: "none",- position: "absolute",- right: -5,- width: 16,- zIndex: 1,- }}- >- <HugeiconsIcon- absoluteStrokeWidth- color={spaceAppBackgroundColor}- fill="#08C225"- icon={FavouriteIcon}- size={14}- strokeWidth={1.25}- />- </Box>- </Box>+ {(isPostLike || isDiscussion) && (+ <SpacePostPreviewThumbnail post={preview} />)}</Box>{showPostSomething && (@@ -609,8 +595,27 @@ const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({const mounted = React.useRef(true);const loadGeneration = React.useRef(0);+ React.useEffect(() => {+ let timeout: ReturnType<typeof setTimeout>;+ const reload = () => {+ if (document.visibilityState != "visible" || !navigator.onLine)+ return;+ clearTimeout(timeout);+ timeout = setTimeout(() => setRefresh((value) => value + 1), 100);+ };+ window.addEventListener("focus", reload);+ window.addEventListener("online", reload);+ document.addEventListener("visibilitychange", reload);+ return () => {+ clearTimeout(timeout);+ window.removeEventListener("focus", reload);+ window.removeEventListener("online", reload);+ document.removeEventListener("visibilitychange", reload);+ };+ }, []);+const loadPostPreview = React.useCallback(- (postId: number) => {+ (postId: number, postSpaceId = spaceId) => {if (postPreviews.current.generation != refresh) {postPreviews.current = {generation: refresh,@@ -619,7 +624,7 @@ const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({}let preview = postPreviews.current.items.get(postId);if (!preview) {- const target = { spaceId, postId };+ const target = { spaceId: postSpaceId, postId };preview = loadCurrentPostPreview(target, spaceId).then((post) => post ?? { ...target, isUnavailable: true }).catch((error: unknown) => {@@ -682,7 +687,7 @@ const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({items: [...new Map(page.items.map((item) => [- `${item.kind}:${item.postId ?? item.id}`,+ notificationGroupKey(item),item,]),).values(),@@ -727,7 +732,9 @@ const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({}).catch((error: unknown) => {log.error("Failed to load notifications", error);- if (!cancelled) setLoadError("refresh");+ if (!cancelled) {+ setLoadError("refresh");+ }}).finally(() => {if (!cancelled) setLoading(undefined);@@ -737,23 +744,6 @@ const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({};}, [spaceId, refresh]);- React.useEffect(() => {- const reload = () => {- if (document.visibilityState == "visible")- setRefresh((value) => value + 1);- };- window.addEventListener("focus", reload);- window.addEventListener("online", reload);- window.addEventListener(spacePostDeletedEvent, reload);- document.addEventListener("visibilitychange", reload);- return () => {- window.removeEventListener("focus", reload);- window.removeEventListener("online", reload);- window.removeEventListener(spacePostDeletedEvent, reload);- document.removeEventListener("visibilitychange", reload);- };- }, []);-const markRead = React.useCallback(async (ids: string[]) => {ids.forEach((id) => attemptedReadIDs.current.add(id));@@ -850,9 +840,8 @@ const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({(item) =>!current.some((existing) =>- existing.kind == item.kind &&- (existing.postId ?? existing.id) ==- (item.postId ?? item.id),+ notificationGroupKey(existing) ==+ notificationGroupKey(item),),),]);@@ -917,7 +906,7 @@ const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({>{section.items.map((group) => (<NotificationRow- key={`${group.kind}:${group.postId ?? group.id}`}+ key={notificationGroupKey(group)}group={group}isNew={newIDs.has(group.id)}spaceId={spaceId}diff --git a/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx b/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsxindex a9ffedde1b..0589c15585 100644--- a/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx+++ b/web/apps/space/src/pages/app/posts/[spaceId]/[postId].tsx@@ -53,6 +53,7 @@ const viewerPhotoFromPost = (post: SpacePost) => ({alt: `${post.name} post`,avatarUrl: post.avatarUrl,caption: post.caption,+ commentCount: post.commentCount,friendID: post.friendID,height: post.height,photos: post.photos,@@ -78,6 +79,7 @@ const Page: React.FC = () => {const spaceId =valueFromQuery(router.query.spaceId) ?? pathParams.spaceId ?? "";const postId = postIdFromQuery(router.query.postId) ?? pathParams.postId;+ const targetCommentId = valueFromQuery(router.query.comment);const photoId =valueFromQuery(router.query.photo) ??(typeof window == "undefined"@@ -201,10 +203,12 @@ const Page: React.FC = () => {<><SpacePageMeta themeColor={postBackground} /><SpaceFileViewer- key={`${post.postId}:${photoId ?? ""}`}+ key={`${post.postId}:${photoId ?? ""}:${targetCommentId ?? ""}`}photo={viewerPhotoFromPost(post)}photos={photos}initialPhotoIndex={photoIndex}+ commentsOnOpen={router.query.comments == "1"}+ targetCommentId={targetCommentId}onLoadPhoto={loadCurrentSpacePostAssetURL}postActionMode={isOwnPost ? "hidden" : "like-only"}onClose={closePost}diff --git a/web/apps/space/src/screens/HomeScreen.tsx b/web/apps/space/src/screens/HomeScreen.tsxindex c92d5d3fb5..b213c21f06 100644--- a/web/apps/space/src/screens/HomeScreen.tsx+++ b/web/apps/space/src/screens/HomeScreen.tsx@@ -10,6 +10,7 @@ import { Box, Skeleton } from "@mui/material";import { visuallyHidden } from "@mui/utils";import { SpaceActionToast } from "components/ActionToast";import { SpaceCaptionText } from "components/CaptionText";+import { SpaceCommentsButton } from "components/CommentComposer";import {focusFeedPost,registerFeedPost,@@ -34,6 +35,7 @@ import { SpacePostGrid } from "components/PostGrid";import { SpacePostLikeHeart } from "components/PostLikeHeart";import { SpacePostPhotosCounter } from "components/PostPhotosCounter";import { SpacePostPhotosDots } from "components/PostPhotosDots";+import { SpacePostInputButton } from "components/PostReplyControls";import { SpacePostTile } from "components/PostTile";import { SpacePWAInstallPrompt } from "components/PWAInstallPrompt";import { SpaceLoadingSpinner } from "components/RouteFallback";@@ -42,6 +44,7 @@ import { SpaceSkipLink } from "components/SkipLink";import { viewerOriginKey } from "components/viewer-transition";import log from "ente-base/log";import { useBrowserBackClose } from "hooks/use-browser-back-close";+import { useCommentCount } from "hooks/use-comment-count";import { useDecodedImage } from "hooks/use-decoded-image";import React, { useState } from "react";import type { SetupProfile } from "screens/SetupProfileScreen";@@ -91,11 +94,10 @@ const feedActionForeground = spaceText;const feedTimestampForeground = "#D9D9D9";const feedSkeletonElementBackground = spaceSurfaceHover;const textBase = spaceText;-const textSecondary = spaceTextMuted;const dangerColor = "#F63A3A";const feedAvatarSize = 38;-const feedLikeActionSize = spaceTouchTargetSize;-const feedActionIconSize = 20;+const feedLikeActionSize = 48;+const feedActionIconSize = 26;const feedHorizontalPadding = "8px";const feedMediaLoadRootMargin = "640px 0px";const feedLoadMoreRootMargin = "0px 0px 800px 0px";@@ -153,9 +155,11 @@ interface FeedPhotoDimensions {interface SelectedHomeViewer {photoIndex: number;photos: SpaceViewerPhoto[];- focusReplyOnOpen?: boolean;photo: SpaceViewerPhoto;postActionMode?: SpaceViewerPostActionMode;+ privateReplyOnOpen?: boolean;+ commentsOnOpen?: boolean;+ focusCommentOnOpen?: boolean;}interface FeedLayoutSnapshot {@@ -416,6 +420,7 @@ interface FeedItemProps {frameAspectRatio?: number;avatarUrl: string | null;caption?: string;+ commentCount?: number;friendID: string;imageUrl?: string;isAvatarPending: boolean;@@ -427,7 +432,11 @@ interface FeedItemProps {onLoadImage?: (index: number) => Promise<string | undefined>;onLoadVideo?: SpacePostAssetURLLoader;onOpenFriend?: (friendID: string, username?: string) => void;- onOpenPhoto?: (photo: SpaceViewerPhoto, focusReplyOnOpen?: boolean) => void;+ onOpenPhoto?: (+ photo: SpaceViewerPhoto,+ action?: "comment" | "comments" | "reply",+ ) => void;+ canReplyPrivately?: boolean;onOpenProfile?: () => void;onSetPostLiked?: (postId: number, liked: boolean) => Promise<void>;postId: number;@@ -437,6 +446,7 @@ interface FeedItemProps {timestampMs: number;username?: string;viewerLiked: boolean;+ viewerSpaceId?: string;}interface AddedFriendToastProps {@@ -849,6 +859,7 @@ const FeedItem: React.FC<FeedItemProps> = ({frameAspectRatio: pendingFrameAspectRatio,avatarUrl,caption,+ commentCount: initialCommentCount,friendID,imageUrl,isAvatarPending,@@ -861,6 +872,7 @@ const FeedItem: React.FC<FeedItemProps> = ({onLoadVideo,onOpenFriend,onOpenPhoto,+ canReplyPrivately,onOpenProfile,onSetPostLiked,onRetry,@@ -872,7 +884,13 @@ const FeedItem: React.FC<FeedItemProps> = ({timestampMs,username,viewerLiked,+ viewerSpaceId,}) => {+ const commentCount = useCommentCount(+ viewerSpaceId,+ postId,+ initialCommentCount,+ );const [isLiked, setIsLiked] = useState(viewerLiked);const [muted, setMuted] = useState(true);const [likePopID, setLikePopID] = useState(0);@@ -1045,13 +1063,7 @@ const FeedItem: React.FC<FeedItemProps> = ({const decodedAvatar = useDecodedImage(avatarUrl, true);const isPostUnavailable =isUnavailable || activePhoto.isUnavailable || decodedPhoto.failed;- const showFooter = !isOwnPost && !isPostUnavailable;- const displayImageUrl =- (decodedPhoto.failed- ? undefined- : decodedPhoto.ready- ? decodedPhoto.src- : activePhoto.imageUrl) ?? undefined;+ const showFooter = !isPostUnavailable;const displayAvatarUrl =(decodedAvatar.failed? undefined@@ -1074,14 +1086,14 @@ const FeedItem: React.FC<FeedItemProps> = ({spacePostFrameAspectRatio(feedPhotos.length > 1 ? feedPhotos : [photoDimensions],);- const isPhotoReady = Boolean(displayImageUrl) && decodedPhoto.ready;const showSoundControl =!isPostUnavailable && shouldPreloadVideo && Boolean(activePhoto.video);- const canOpenPhoto =- !isPostUnavailable && isPhotoReady && Boolean(onOpenPhoto);- const openPhoto = (focusReplyOnOpen = false, index = photoIndex) => {+ const openPhoto = (+ index = photoIndex,+ action?: "comment" | "comments" | "reply",+ ) => {const selectedPhoto = feedPhotos[index]!;- if (!selectedPhoto.imageUrl || isUnavailable) return;+ if (isUnavailable) return;onOpenPhoto?.({@@ -1089,12 +1101,13 @@ const FeedItem: React.FC<FeedItemProps> = ({alt: `${name} post`,avatarUrl: displayAvatarUrl ?? null,caption,+ commentCount,friendID,height:index == photoIndex? photoDimensions.height: selectedPhoto.height,- imageUrl: selectedPhoto.imageUrl,+ imageUrl: selectedPhoto.imageUrl ?? "",name,postId,postPhotoIndex: index,@@ -1108,7 +1121,7 @@ const FeedItem: React.FC<FeedItemProps> = ({? photoDimensions.width: selectedPhoto.width,},- focusReplyOnOpen,+ action,);};const handleLikeClick = () => {@@ -1455,9 +1468,7 @@ const FeedItem: React.FC<FeedItemProps> = ({}onLoadVideo={onLoadVideo}onOpenPhoto={- onOpenPhoto- ? () => openPhoto(false, index)- : undefined+ onOpenPhoto ? () => openPhoto(index) : undefined}shouldLoad={(shouldPreloadVideo && Boolean(photo.video)) ||@@ -1712,69 +1723,62 @@ const FeedItem: React.FC<FeedItemProps> = ({/>)}</Box>- {showFooter && (+ {showFooter && viewerSpaceId && spaceId && (<Boxsx={{- alignItems: "center",- boxSizing: "border-box",- display: "grid",- gap: "8px",- gridTemplateColumns: "minmax(0, 1fr) auto",- minHeight: feedLikeActionSize,- p: "8px",- width: "100%",+ display: "flex",+ flexDirection: "column",+ gap: 1,+ p: "12px",}}>- <Box- component="button"- type="button"- aria-label={`Reply privately to ${firstName}'s post`}- disabled={!canOpenPhoto}- onClick={() => openPhoto(true)}- sx={{- appearance: "none",- bgcolor: feedActionBackground,- border: 0,- borderRadius: "16px",- color: "#C4C4C8",- cursor: canOpenPhoto ? "pointer" : "default",- fontFamily: '"Inter Variable", Inter, sans-serif',- fontSize: 14,- fontWeight: 500,- height: feedLikeActionSize,- lineHeight: "20px",- minWidth: 0,- overflow: "hidden",- px: "16px",- textAlign: "left",- textOverflow: "ellipsis",- transition:- "background-color 120ms ease, transform 120ms ease",- whiteSpace: "nowrap",- "&:active": {- transform: canOpenPhoto- ? "scale(0.99)"- : undefined,- },- "&:disabled": { color: textSecondary },- "&:focus-visible": {- outline: `2px solid ${green}`,- outlineOffset: 2,- },- "&:not(:disabled):hover": {- bgcolor: feedActionBackgroundHover,- color: textBase,- },- }}- >- Reply...+ <Box sx={{ display: "flex", alignItems: "center", gap: 1 }}>+ {isOwnPost && (+ <SpacePostInputButton+ label="Add a comment"+ placeholder="Add a comment..."+ backgroundColor={feedActionBackground}+ hoverBackgroundColor={feedActionBackgroundHover}+ disabled={!onOpenPhoto}+ onClick={() => openPhoto(photoIndex, "comment")}+ />+ )}+ {!isOwnPost &&+ canReplyPrivately &&+ activePhoto.imageAsset &&+ onOpenPhoto && (+ <SpacePostInputButton+ label="Reply privately"+ placeholder="Send a messageโฆ"+ backgroundColor={feedActionBackground}+ hoverBackgroundColor={+ feedActionBackgroundHover+ }+ onClick={() =>+ openPhoto(photoIndex, "reply")+ }+ />+ )}+ {!isOwnPost && (+ <SpaceCommentsButton+ count={commentCount}+ backgroundColor={feedActionBackground}+ hoverBackgroundColor={feedActionBackgroundHover}+ disabled={!onOpenPhoto}+ onClick={() =>+ openPhoto(photoIndex, "comments")+ }+ />+ )}+ {!isOwnPost && (+ <FeedLikeButton+ isLiked={isLiked}+ onClick={handleLikeClick}+ popID={likePopID}+ toggleID={likeToggleID}+ />+ )}</Box>- <FeedLikeButton- isLiked={isLiked}- onClick={handleLikeClick}- popID={likePopID}- toggleID={likeToggleID}- /></Box>)}</Box>@@ -1980,7 +1984,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({const openFeedPhoto = (post: SpacePost,photo: SpaceViewerPhoto,- focusReplyOnOpen = false,+ action?: "comment" | "comments" | "reply",) => {const isOwnPost =Boolean(viewerSpaceId) && photo.friendID == viewerSpaceId;@@ -1994,9 +1998,11 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({setSelectedViewer({photoIndex,photos,- focusReplyOnOpen: isOwnPost ? false : focusReplyOnOpen,photo,postActionMode: isOwnPost ? "hidden" : "like-only",+ privateReplyOnOpen: action == "reply",+ commentsOnOpen: action == "comments" || action == "comment",+ focusCommentOnOpen: action == "comment",});};const closeSelectedPhoto = () => {@@ -2158,9 +2164,11 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({onLoadImage={(index) => loadFeedPostImage(postPhotos[index]!)}onLoadVideo={onLoadPostImage}onOpenFriend={onOpenFriend}- onOpenPhoto={(photo, focusReply) =>- openFeedPhoto({ ...item, photos }, photo, focusReply)+ onOpenPhoto={(photo, action) =>+ openFeedPhoto({ ...item, photos }, photo, action)}+ canReplyPrivately={Boolean(onReplyToPost)}+ commentCount={item.commentCount}onOpenProfile={onOpenProfile}onSetPostLiked={onSetPostLiked}photos={photos}@@ -2179,6 +2187,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({timestampMs={item.timestampMs}username={item.username}viewerLiked={item.viewerLiked}+ viewerSpaceId={viewerSpaceId}/>);};@@ -2213,6 +2222,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({onOpenProfile={onOpenProfile}photoCount={item.photoCount}postId={0}+ spaceId={item.spaceId}onRetry={onRetryPost ? () => void onRetryPost(item.id) : undefined}@@ -2226,6 +2236,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({}timestampMs={item.timestampMs}viewerLiked={false}+ viewerSpaceId={viewerSpaceId}/>);};@@ -2692,7 +2703,6 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({<SpaceFileViewerref={viewerRef}closeOnSwipePastEnd- focusReplyOnOpen={selectedViewer.focusReplyOnOpen}photo={selectedViewer.photo}photos={selectedViewer.photos}photoIndex={selectedViewer.photoIndex}@@ -2709,6 +2719,9 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({}}onLoadPhoto={onLoadPostImage}postActionMode={selectedViewer.postActionMode}+ privateReplyOnOpen={selectedViewer.privateReplyOnOpen}+ commentsOnOpen={selectedViewer.commentsOnOpen}+ focusCommentOnOpen={selectedViewer.focusCommentOnOpen}onClose={closeSelectedPhoto}onOpenProfile={selectedPhotoIsOwn && onOpenProfilediff --git a/web/apps/space/src/screens/MessagesScreen.tsx b/web/apps/space/src/screens/MessagesScreen.tsxindex 43d46583b3..f56a4bdd05 100644--- a/web/apps/space/src/screens/MessagesScreen.tsx+++ b/web/apps/space/src/screens/MessagesScreen.tsx@@ -12,8 +12,6 @@ import {Box,ClickAwayListener,Grow,- MenuItem,- MenuList,Popper,useMediaQuery,} from "@mui/material";@@ -21,6 +19,13 @@ import { SpaceActionToast } from "components/ActionToast";import { SpaceActivityAvatar as Avatar } from "components/ActivityList";import { SpaceConversationPokeButton } from "components/ConversationPokeButton";import { SpaceLiveStatus } from "components/LiveStatus";+import {+ CopyIcon,+ DeleteIcon,+ MessageActionMenuItem,+ MessageActionMenuList,+ ReplyIcon,+} from "components/MessageActionMenu";import {MessageQuickReactions,MessageReactionPicker,@@ -31,6 +36,7 @@ import {SpacePostVideoBadge,} from "components/PostPhotosBadge";import { SpacePostPreviewThumbnail } from "components/PostPreviewThumbnail";+import { ReplyComposerPreview } from "components/ReplyComposerPreview";import { SpaceLoadingSpinner } from "components/RouteFallback";import { SpaceShareInviteButton } from "components/ShareInviteButton";import { SpaceSkipLink } from "components/SkipLink";@@ -56,8 +62,6 @@ import {spaceAppBackground,spaceAppBackgroundColor,spaceDialogBackground,- spaceMenuBackground,- spaceMenuHover,spaceOnAccent,spaceSurface,spaceSurfaceHover,@@ -620,109 +624,8 @@ const bodyBubblesCanGroup = ();};-const ReplyIcon: React.FC = () => (- <svg- width="12"- height="9"- viewBox="0 0 12 9"- fill="none"- xmlns="http://www.w3.org/2000/svg"- >- <path- fillRule="evenodd"- clipRule="evenodd"- d="M4.5241 0.242677C4.62341 0.34442 4.67919 0.482337 4.67919 0.626134C4.67919 0.76993 4.62341 0.907847 4.5241 1.00959L1.89369 3.70102H7.68483C8.3587 3.70102 9.35854 3.9036 10.2042 4.52653C11.0775 5.17045 11.7507 6.23762 11.7507 7.86116C11.7507 8.00507 11.6948 8.14309 11.5953 8.24485C11.4959 8.34661 11.361 8.40378 11.2203 8.40378C11.0797 8.40378 10.9448 8.34661 10.8453 8.24485C10.7459 8.14309 10.69 8.00507 10.69 7.86116C10.69 6.59069 10.1844 5.84982 9.58481 5.40776C8.95761 4.94544 8.18899 4.78627 7.68483 4.78627H1.89369L4.5241 7.4777C4.5762 7.52738 4.61799 7.58728 4.64698 7.65384C4.67597 7.72041 4.69155 7.79226 4.69281 7.86512C4.69406 7.93798 4.68096 8.01035 4.65429 8.07791C4.62762 8.14548 4.58792 8.20686 4.53756 8.25839C4.4872 8.30991 4.42722 8.35053 4.36118 8.37782C4.29515 8.40512 4.22442 8.41852 4.15321 8.41723C4.082 8.41595 4.01178 8.4 3.94673 8.37034C3.88167 8.34068 3.82313 8.29792 3.77457 8.24461L0.23908 4.6271C0.139767 4.52536 0.0839844 4.38744 0.0839844 4.24364C0.0839844 4.09985 0.139767 3.96193 0.23908 3.86019L3.77457 0.242677C3.87401 0.141061 4.0088 0.0839844 4.14934 0.0839844C4.28987 0.0839844 4.42466 0.141061 4.5241 0.242677Z"- fill="currentColor"- stroke="currentColor"- strokeWidth="0.166667"- />- </svg>-);--const DeleteIcon: React.FC = () => (- <svg- width="13"- height="15"- viewBox="0 0 13 15"- fill="none"- xmlns="http://www.w3.org/2000/svg"- >- <path- d="M11.5 2.83203L11.0869 9.51543C10.9813 11.223 10.9285 12.0768 10.5005 12.6906C10.2889 12.9941 10.0165 13.2502 9.70047 13.4427C9.0614 13.832 8.206 13.832 6.49513 13.832C4.78208 13.832 3.92553 13.832 3.28603 13.442C2.96987 13.2492 2.69733 12.9926 2.48579 12.6886C2.05792 12.0738 2.0063 11.2188 1.90307 9.50883L1.5 2.83203M0.5 2.83333H12.5M9.2038 2.83333L8.74873 1.89449C8.4464 1.27084 8.2952 0.959013 8.03447 0.76454C7.97667 0.7214 7.9154 0.683027 7.85133 0.6498C7.5626 0.5 7.21607 0.5 6.523 0.5C5.81253 0.5 5.45733 0.5 5.16379 0.65608C5.09873 0.690673 5.03665 0.7306 4.97819 0.775447C4.71443 0.9778 4.56709 1.30103 4.27241 1.94751L3.86861 2.83333M4.83203 10.166V6.16602M8.16797 10.166V6.16602"- stroke="currentColor"- strokeLinecap="round"- />- </svg>-);--const CopyIcon: React.FC = () => (- <svg- width="14"- height="14"- viewBox="0 0 14 14"- fill="none"- xmlns="http://www.w3.org/2000/svg"- >- <path- d="M4.5 4.5V2.5C4.5 1.39543 5.39543 0.5 6.5 0.5H11.5C12.6046 0.5 13.5 1.39543 13.5 2.5V7.5C13.5 8.60457 12.6046 9.5 11.5 9.5H9.5M2.5 4.5H7.5C8.60457 4.5 9.5 5.39543 9.5 6.5V11.5C9.5 12.6046 8.60457 13.5 7.5 13.5H2.5C1.39543 13.5 0.5 12.6046 0.5 11.5V6.5C0.5 5.39543 1.39543 4.5 2.5 4.5Z"- stroke="currentColor"- strokeLinecap="round"- strokeLinejoin="round"- />- </svg>-);-const messageActionsTransitionDuration = { enter: 300, exit: 100 };-const MessageActionMenuItem: React.FC<{- icon: React.ReactNode;- label: string;- onClick: () => void;- tone?: "default" | "danger";-}> = ({ icon, label, onClick, tone = "default" }) => (- <MenuItem- disableRipple- onClick={onClick}- sx={{- WebkitTapHighlightColor: "transparent",- borderRadius: "12px",- color: tone == "danger" ? dangerColor : textBase,- gap: "8px",- minHeight: spaceTouchTargetSize,- outline: 0,- px: "8px",- py: "7px",- "&.Mui-focusVisible": {- bgcolor:- tone == "danger"- ? "rgba(246, 58, 58, 0.14)"- : spaceMenuHover,- outline: 0,- },- "&:focus": { outline: 0 },- "&:focus-visible": { outline: 0 },- "&:hover": {- bgcolor:- tone == "danger"- ? "rgba(246, 58, 58, 0.14)"- : spaceMenuHover,- },- }}- >- {icon}- <Box- sx={{- fontFamily: '"Inter Variable", Inter, sans-serif',- fontSize: 13,- fontWeight: 650,- lineHeight: "18px",- }}- >- {label}- </Box>- </MenuItem>-);-const messageActionsTriggerSize = 24;const messageActionsTriggerOffset = -6;@@ -2774,7 +2677,7 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({}}/>)}- <MenuList+ <MessageActionMenuListaria-label="Message actions"autoFocus={isContextMessagePoke ||@@ -2784,28 +2687,10 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({onKeyDown={handleMessageActionsKeyDown}- sx={{- alignSelf: "flex-start",- bgcolor:- spaceMenuBackground,- borderRadius: "16px",- boxShadow:- "0 0 0 1px rgba(255, 255, 255, 0.08), 0 8px 24px rgba(0, 0, 0, 0.32)",- minWidth: 132,- outline: 0,- p: "4px",- width: "max-content",- "&:focus": {- outline: 0,- },- "&:focus-visible": {- outline: 0,- },- }}variant="menu">{messageActionMenuItems}- </MenuList>+ </MessageActionMenuList></Box></Grow></ClickAwayListener>@@ -2825,121 +2710,23 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({}}>{replyingTo && (- <Box- sx={{- bgcolor: spaceSurface,- borderLeft: `3px solid ${green}`,- borderRadius: "12px",- boxSizing: "border-box",- display: "grid",- gridTemplateColumns:- "minmax(0, 1fr)",- maxWidth: "100%",- overflow: "hidden",- p: "9px 40px 9px 12px",- position: "relative",- width: "100%",- }}- >- <Box- sx={{- maxWidth: "100%",- minWidth: 0,- overflow: "hidden",- }}- >- <Box- sx={{- color: textSecondary,- fontFamily:- '"Inter Variable", Inter, sans-serif',- fontSize: 12,- fontWeight: 650,- lineHeight: "16px",- overflow: "hidden",- textOverflow:- "ellipsis",- whiteSpace: "nowrap",- }}- >- {isCurrentProfileMessage(- replyingTo,- profile,- )- ? "You"- : firstNameFrom(- replyingTo.sender.fullName.trim() ||- replyingTo- .sender- .username ||- selectedName,- )}- </Box>- <Box- sx={{- color: textBase,- fontFamily:- '"Inter Variable", Inter, sans-serif',- fontSize: 13,- fontWeight: 600,- lineHeight: "18px",- maxWidth: "100%",- overflow: "hidden",- overflowWrap:- "anywhere",- textOverflow:- "ellipsis",- whiteSpace: "nowrap",- }}- >- {truncateMessageText(- replyingTo.text,- )}- </Box>- </Box>- <Box- component="button"- type="button"- aria-label="Cancel reply"- onClick={() => {- setReplyingTo(null);- }}- sx={{- alignItems: "center",- bgcolor: "transparent",- border: 0,- borderRadius: "50%",- color: textSecondary,- cursor: "pointer",- display: "flex",- height: spaceTouchTargetSize,- justifyContent: "center",- p: 0,- position: "absolute",- right: 0,- top: 0,- width: spaceTouchTargetSize,- "&:focus-visible": {- outline: `2px solid ${green}`,- outlineOffset: 2,- },- "&:hover": {- color: textBase,- },- "& svg": {- position: "absolute",- right: 8,- top: 8,- },- }}- >- <HugeiconsIcon- icon={Cancel01Icon}- size={16}- strokeWidth={1.8}- />- </Box>- </Box>+ <ReplyComposerPreview+ name={+ isCurrentProfileMessage(+ replyingTo,+ profile,+ )+ ? "You"+ : firstNameFrom(+ replyingTo.sender.fullName.trim() ||+ replyingTo.sender+ .username ||+ selectedName,+ )+ }+ text={replyingTo.text}+ onCancel={() => setReplyingTo(null)}+ />)}<Boxsx={{diff --git a/web/apps/space/src/services/comment-counts.ts b/web/apps/space/src/services/comment-counts.tsnew file mode 100644index 0000000000..8207ff0486--- /dev/null+++ b/web/apps/space/src/services/comment-counts.ts@@ -0,0 +1,28 @@+const counts = new Map<string, number>();+const listeners = new Set<() => void>();++export const cachedCommentCount = (viewer?: string, postId?: number) =>+ counts.get(`${viewer}:${postId}`);++export const subscribeToCommentCounts = (listener: () => void) => {+ listeners.add(listener);+ return () => {+ listeners.delete(listener);+ };+};++export const rememberCommentCount = (+ viewer: string,+ postId: number,+ count: number,+) => {+ const key = `${viewer}:${postId}`;+ if (counts.get(key) == count) return;+ counts.set(key, count);+ listeners.forEach((listener) => listener());+};++export const clearCommentCounts = () => {+ counts.clear();+ listeners.forEach((listener) => listener());+};diff --git a/web/apps/space/src/services/feed-cache.ts b/web/apps/space/src/services/feed-cache.tsindex e6e40d4525..0f69c0e72c 100644--- a/web/apps/space/src/services/feed-cache.ts+++ b/web/apps/space/src/services/feed-cache.ts@@ -374,7 +374,7 @@ export const removeCachedSpaceFeedPostsBySpace = (export const patchCachedSpaceFeedPost = (spaceId: string,postId: number,- patch: Partial<Pick<SpacePost, "caption" | "viewerLiked">>,+ patch: Partial<Pick<SpacePost, "caption" | "viewerLiked" | "commentCount">>,) =>updateCachedSpaceFeed(spaceId, (snapshot) => ({...snapshot,diff --git a/web/apps/space/src/services/post-cache.ts b/web/apps/space/src/services/post-cache.tsindex f8e31c8ba2..4b0c11a703 100644--- a/web/apps/space/src/services/post-cache.ts+++ b/web/apps/space/src/services/post-cache.ts@@ -20,6 +20,7 @@ export const CachedSpacePost = z.object({avatarSize: z.number().optional(),avatarUpdatedAt: z.string().optional(),caption: z.string().optional(),+ commentCount: z.number().optional(),friendID: z.string(),height: z.number().optional(),video: CachedSpacePostVideo.optional(),diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.tsindex 43a2f3c417..766eb3e437 100644--- a/web/apps/space/src/services/space.ts+++ b/web/apps/space/src/services/space.ts@@ -19,6 +19,7 @@ import {type SpaceActorResponse,type SpaceLinkCtxHandle,} from "ente-space-wasm";+import { rememberCommentCount } from "services/comment-counts";import {invalidateCachedSpaceFeed,patchCachedSpaceFeedPost,@@ -61,6 +62,7 @@ interface SpacePostBase {avatarUpdatedAt?: string;avatarUrl?: string | null;caption?: string;+ commentCount?: number;friendID: string;height?: number;name: string;@@ -445,22 +447,28 @@ const postPhotosFromResponse = (post: PostResponse): SpacePostPhoto[] =>const postBaseFromResponse = (post: PostResponse,author: FriendProfile,-): SpacePostBase => ({- avatarKeyVersion: author.avatarKeyVersion,- avatarObjectID: author.avatarObjectID,- avatarSize: author.avatarSize,- avatarUpdatedAt: author.avatarUpdatedAt,- avatarUrl: author.avatarUrl,- caption: post.caption,- friendID: author.id,- isUnavailable: post.isUnavailable,- name: author.fullName || author.username,- postId: post.postId,- spaceId: post.spaceId,- timestampMs: timestampMsFromSpaceDate(post.createdAt),- username: author.username,- viewerLiked: post.viewerLiked,-});+ viewerSpaceId?: string,+): SpacePostBase => {+ if (viewerSpaceId)+ rememberCommentCount(viewerSpaceId, post.postId, post.commentCount);+ return {+ avatarKeyVersion: author.avatarKeyVersion,+ avatarObjectID: author.avatarObjectID,+ avatarSize: author.avatarSize,+ avatarUpdatedAt: author.avatarUpdatedAt,+ avatarUrl: author.avatarUrl,+ caption: post.caption,+ commentCount: post.commentCount,+ friendID: author.id,+ isUnavailable: post.isUnavailable,+ name: author.fullName || author.username,+ postId: post.postId,+ spaceId: post.spaceId,+ timestampMs: timestampMsFromSpaceDate(post.createdAt),+ username: author.username,+ viewerLiked: post.viewerLiked,+ };+};const postFromAccountPost = async (ctx: SpaceAccountCtxHandle,@@ -469,7 +477,7 @@ const postFromAccountPost = async (viewerSpaceId?: string,): Promise<SpacePost> => {const author = actorProfile(post.author);- const base = postBaseFromResponse(post, author);+ const base = postBaseFromResponse(post, author, viewerSpaceId);if (post.isUnavailable) {return { ...base, isUnavailable: true };}@@ -499,9 +507,12 @@ const postFromAccountPost = async (};};-const profilePostFromPost = (post: PostResponse): SpaceProfilePost => {+const profilePostFromPost = (+ post: PostResponse,+ viewerSpaceId?: string,+): SpaceProfilePost => {const author = actorProfile(post.author);- const base = postBaseFromResponse(post, author);+ const base = postBaseFromResponse(post, author, viewerSpaceId);if (post.isUnavailable) {return { ...base, avatarUrl: null, isUnavailable: true };}@@ -518,8 +529,11 @@ const profilePostFromPost = (post: PostResponse): SpaceProfilePost => {};};-const profilePostPageFromPage = (page: PostPage): SpaceProfilePostPage => ({- items: page.items.map(profilePostFromPost),+const profilePostPageFromPage = (+ page: PostPage,+ viewerSpaceId?: string,+): SpaceProfilePostPage => ({+ items: page.items.map((post) => profilePostFromPost(post, viewerSpaceId)),nextCursor: page.nextCursor || undefined,});@@ -1013,6 +1027,11 @@ export const loadCurrentUnreadStatus = async (};export interface SpaceNotification {+ postSpaceId?: string;+ postOwnerSlug?: string;+ postOwnerName?: string;+ commentId?: string;+ replyToId?: string;id: string;notificationIds: string[];kind: string;@@ -1031,6 +1050,11 @@ export const loadCurrentNotifications = async (const ctx = await ensureCurrentSpaceContext();try {const page = await ctx.listNotifications(spaceId, cursor, 20);+ const friends = page.items.some(+ (item) => item.kind == "comment" && item.postSpaceId != spaceId,+ )+ ? await loadCurrentSpaceFriends(spaceId)+ : [];return {items: await Promise.all(page.items.map(async (item): Promise<SpaceNotification> => {@@ -1047,6 +1071,14 @@ export const loadCurrentNotifications = async ();return {id: item.notificationId,+ postSpaceId: item.postSpaceId ?? undefined,+ postOwnerSlug: item.postOwnerSlug ?? undefined,+ postOwnerName: friends.find(+ (friend) =>+ friendSpaceId(friend) == item.postSpaceId,+ )?.fullName,+ commentId: item.commentId ?? undefined,+ replyToId: item.replyToId ?? undefined,notificationIds: item.notificationIds,kind: item.kind,actors,@@ -1095,6 +1127,7 @@ export const loadCurrentSpaceProfilePostsPage = async (cursor ?? null,250,),+ viewerSpaceId,);return page;} finally {@@ -1640,3 +1673,130 @@ export const updateCurrentPostCaption = async (releaseCurrentSpaceContext(ctx);}};++export interface SpaceComment {+ commentId: string;+ unreadNotificationIds: string[];+ author?: FriendProfile;+ parentId: string;+ replyToId: string;+ text?: string;+ deleted: boolean;+ createdAt: string;+ canDelete: boolean;+ reactions: { actor: FriendProfile; emoji: string; isOwn: boolean }[];+}++export const loadCurrentComments = async (+ viewer: string,+ postSpaceId: string,+ postId: number,+) => {+ const ctx = await ensureCurrentSpaceContext();+ try {+ const items: SpaceComment[] = [];+ let cursor: string | undefined;+ do {+ const page = await ctx.listComments(+ viewer,+ postSpaceId,+ BigInt(postId),+ cursor,+ );+ items.push(+ ...page.items.map((item) => ({+ ...item,+ text: item.text ?? undefined,+ author: item.author ? actorProfile(item.author) : undefined,+ reactions: item.reactions.map((reaction) => ({+ ...reaction,+ actor: actorProfile(reaction.actor),+ })),+ })),+ );+ cursor = page.nextCursor || undefined;+ } while (cursor);+ const count = items.filter((item) => !item.deleted).length;+ rememberCommentCount(viewer, postId, count);+ await patchCachedSpaceFeedPost(viewer, postId, { commentCount: count });+ return items;+ } finally {+ releaseCurrentSpaceContext(ctx);+ }+};++export const createCurrentComment = async (+ viewer: string,+ postSpaceId: string,+ postId: number,+ commentId: string,+ replyToId: string | undefined,+ text: string,+) => {+ const ctx = await ensureCurrentSpaceContext();+ try {+ await ctx.createComment(+ viewer,+ postSpaceId,+ BigInt(postId),+ commentId,+ replyToId,+ normalizeSpaceMessageText(text),+ );+ } finally {+ releaseCurrentSpaceContext(ctx);+ }+};++export const deleteCurrentComment = async (+ viewer: string,+ postId: number,+ commentId: string,+) => {+ const ctx = await ensureCurrentSpaceContext();+ try {+ await ctx.deleteComment(viewer, BigInt(postId), commentId);+ } finally {+ releaseCurrentSpaceContext(ctx);+ }+};++export const setCurrentCommentReaction = async (+ viewer: string,+ postSpaceId: string,+ postId: number,+ commentId: string,+ emoji?: string,+) => {+ const ctx = await ensureCurrentSpaceContext();+ try {+ await ctx.setCommentReaction(+ viewer,+ postSpaceId,+ BigInt(postId),+ commentId,+ emoji,+ );+ } finally {+ releaseCurrentSpaceContext(ctx);+ }+};++export const removeCurrentCommentReaction = async (+ viewer: string,+ postId: number,+ commentId: string,+ actorSpaceId: string,+) => {+ const ctx = await ensureCurrentSpaceContext();+ try {+ await ctx.removeCommentReaction(+ viewer,+ BigInt(postId),+ commentId,+ actorSpaceId,+ );+ } finally {+ releaseCurrentSpaceContext(ctx);+ }+};diff --git a/web/apps/space/src/state/AppStateProvider.tsx b/web/apps/space/src/state/AppStateProvider.tsxindex 53532af79f..10eed4691f 100644--- a/web/apps/space/src/state/AppStateProvider.tsx+++ b/web/apps/space/src/state/AppStateProvider.tsx@@ -10,6 +10,7 @@ import React, {} from "react";import type { SpaceLoginCredentials } from "screens/LoginScreen";import type { SetupProfile } from "screens/SetupProfileScreen";+import { clearCommentCounts } from "services/comment-counts";import { clearSpaceFeedMemoryCache } from "services/feed-cache";import type { PendingSpacePasskeyVerification } from "services/passkey-verification";import { logoutRevokedSpaceSession } from "services/persistent-session";@@ -586,6 +587,7 @@ export const SpaceAppStateProvider: React.FC<React.PropsWithChildren> = ({clearCurrentSpaceContext();clearSpaceFriendsCache();clearSpaceFeedMemoryCache();+ clearCommentCounts();setLocalFeedPosts([]);clearSpaceMediaURLCache();applyProfile(null);diff --git a/web/apps/space/src/styles/globals.css b/web/apps/space/src/styles/globals.cssindex 47e55b1005..eb95946f0a 100644--- a/web/apps/space/src/styles/globals.css+++ b/web/apps/space/src/styles/globals.css@@ -61,7 +61,8 @@ html[data-space-ios-pwa].space-app-layout[data-space-conversation],.space-app-layout[data-space-settings],.space-app-layout[data-space-profile],-.space-app-layout[data-space-notifications] {+.space-app-layout[data-space-notifications],+.space-app-layout[data-space-post] {--space-bottom-nav-height: 0px;}diff --git a/web/apps/space/src/utils/comments.ts b/web/apps/space/src/utils/comments.tsnew file mode 100644index 0000000000..f7d931b95b--- /dev/null+++ b/web/apps/space/src/utils/comments.ts@@ -0,0 +1,96 @@+import type { SpaceComment, SpaceNotification } from "services/space";+import { firstNameFrom } from "utils/display";++export const commentNotificationText = (+ notification: SpaceNotification,+ viewer: string,+) => {+ if (notification.kind == "comment_reply") return "Replied to your comment";+ if (notification.kind == "comment_reaction")+ return "Reacted to your comment";+ const isOwnPost = notification.postSpaceId == viewer;+ const ownerName = firstNameFrom(notification.postOwnerName ?? "");+ const post = isOwnPost+ ? "your post"+ : notification.actorCount == 1 &&+ notification.actors[0]?.spaceId == notification.postSpaceId+ ? "their post"+ : ownerName+ ? `${ownerName}'s post`+ : notification.postOwnerSlug+ ? `@${notification.postOwnerSlug}'s post`+ : "a post";+ return `Commented on ${post}`;+};++export type CommentReplyTarget =+ | { status: "selected"; commentId: string }+ | { status: "unavailable" }+ | undefined;++export interface CommentDraft {+ text: string;+ replyTarget?: CommentReplyTarget;+ sending?: boolean;+}++export const validateCommentReplyTarget = (+ target: CommentReplyTarget,+ comments: SpaceComment[],+): CommentReplyTarget => {+ if (target?.status != "selected") return target;+ const comment = comments.find((item) => item.commentId == target.commentId);+ if (+ !comment ||+ comment.deleted ||+ (comment.parentId &&+ !comments.some(+ (root) => root.commentId == comment.parentId && !root.deleted,+ ))+ ) {+ return { status: "unavailable" };+ }+ return target;+};++export const commentThreads = (comments: SpaceComment[]) => {+ const ordered = comments+ .filter((comment) => !comment.deleted)+ .sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));+ return ordered+ .filter((comment) => !comment.parentId)+ .map((comment) => ({+ comment,+ replies: ordered.filter(+ (reply) => reply.parentId == comment.commentId,+ ),+ }));+};++export const groupCommentReactions = (reactions: SpaceComment["reactions"]) => {+ const ordered = [...reactions].sort(+ (a, b) => Number(b.isOwn) - Number(a.isOwn),+ );+ const groups = new Map<string, SpaceComment["reactions"]>();+ for (const reaction of ordered) {+ const group = groups.get(reaction.emoji);+ if (group) group.push(reaction);+ else groups.set(reaction.emoji, [reaction]);+ }+ return [...groups.values()].flat();+};++export const commentReactionPreview = (+ reactions: SpaceComment["reactions"],+) => {+ const counts = new Map<string, number>();+ for (const { emoji } of reactions)+ counts.set(emoji, (counts.get(emoji) ?? 0) + 1);+ const ranked = [...counts].sort(([, a], [, b]) => b - a).slice(0, 3);+ let remaining = 3 - ranked.length;+ return ranked.flatMap(([emoji, count]) => {+ const repeats = Math.min(count - 1, remaining);+ remaining -= repeats;+ return Array<string>(repeats + 1).fill(emoji);+ });+};diff --git a/web/apps/space/src/utils/notifications.ts b/web/apps/space/src/utils/notifications.tsnew file mode 100644index 0000000000..d0eedf3bca--- /dev/null+++ b/web/apps/space/src/utils/notifications.ts@@ -0,0 +1,12 @@+import type { SpaceNotification } from "services/space";++export const notificationGroupKey = (notification: SpaceNotification) =>+ `${notification.kind}:${+ notification.kind == "post_like" || notification.kind == "comment"+ ? notification.postId+ : notification.kind == "comment_reaction"+ ? notification.commentId+ : notification.kind == "comment_reply"+ ? notification.replyToId+ : notification.id+ }`;diff --git a/web/apps/space/src/utils/post-display.ts b/web/apps/space/src/utils/post-display.tsindex 99b03021dc..2eddc55df1 100644--- a/web/apps/space/src/utils/post-display.ts+++ b/web/apps/space/src/utils/post-display.ts@@ -7,6 +7,7 @@ export const profilePostItemsFromPosts = (posts.map((post) => ({avatarUrl: post.avatarUrl,caption: post.caption,+ commentCount: post.commentCount,friendID: post.friendID,height: post.height,id: String(post.postId),diff --git a/web/apps/space/tests/comment-counts.test.ts b/web/apps/space/tests/comment-counts.test.tsnew file mode 100644index 0000000000..9e7692122d--- /dev/null+++ b/web/apps/space/tests/comment-counts.test.ts@@ -0,0 +1,125 @@+import { beforeEach, expect, test, vi } from "vitest";+import {+ cachedCommentCount,+ clearCommentCounts,+ subscribeToCommentCounts,+} from "../src/services/comment-counts";+import { patchCachedSpaceFeedPost } from "../src/services/feed-cache";+import { ensureCurrentSpaceContext } from "../src/services/profile";+import {+ loadCurrentComments,+ loadCurrentFeedPage,+ loadCurrentSpaceProfilePostsPage,+} from "../src/services/space";++vi.mock("ente-base/log", () => ({ default: { warn: vi.fn() } }));+vi.mock("ente-base/log-web", () => ({ logToDisk: vi.fn() }));+vi.mock("ente-accounts/services/accounts-db", () => ({+ savedPartialLocalUser: () => ({ id: 1 }),+}));+vi.mock("services/feed-cache", () => ({ patchCachedSpaceFeedPost: vi.fn() }));+vi.mock("services/profile", () => ({+ ensureCurrentSpaceContext: vi.fn(),+ persistCurrentOwnedSpaces: vi.fn(),+ releaseCurrentSpaceContext: vi.fn(),+}));++const context = {+ listComments: vi.fn(),+ listFeed: vi.fn(),+ listPosts: vi.fn(),+};+const actor = {+ spaceId: "friend",+ spaceSlug: "maya",+ profile: { fullName: "Maya Patel" },+};+const post = (commentCount: number) => ({+ postId: 42,+ spaceId: "friend",+ commentCount,+ author: actor,+ createdAt: "2026-10-19T06:00:00Z",+ photos: [{ asset: {} }],+});++beforeEach(() => {+ vi.resetAllMocks();+ clearCommentCounts();+ vi.mocked(ensureCurrentSpaceContext).mockResolvedValue(+ context as unknown as Awaited<+ ReturnType<typeof ensureCurrentSpaceContext>+ >,+ );+});++test("keeps the updated count after the viewer closes and reopens with an old post snapshot", async () => {+ context.listFeed.mockResolvedValue({ items: [post(0)] });+ const feed = await loadCurrentFeedPage("viewer");+ const snapshot = feed.items[0]!;+ const updateViewer = vi.fn();+ const closeViewer = subscribeToCommentCounts(updateViewer);++ context.listComments.mockResolvedValue({+ items: [{ commentId: "comment", deleted: false, reactions: [] }],+ });+ await loadCurrentComments("viewer", "friend", 42);+ expect(updateViewer).toHaveBeenCalledOnce();+ expect(patchCachedSpaceFeedPost).toHaveBeenCalledWith("viewer", 42, {+ commentCount: 1,+ });+ closeViewer();++ expect(snapshot.commentCount).toBe(0);+ expect(cachedCommentCount("viewer", snapshot.postId)).toBe(1);+});++test("counts replies across pages and removes deleted comments from the total", async () => {+ context.listComments+ .mockResolvedValueOnce({+ items: [{ commentId: "parent", deleted: false, reactions: [] }],+ nextCursor: "replies",+ })+ .mockResolvedValueOnce({+ items: [+ {+ commentId: "reply",+ parentId: "parent",+ deleted: false,+ reactions: [],+ },+ { commentId: "deleted", deleted: true, reactions: [] },+ ],+ });+ await loadCurrentComments("viewer", "friend", 42);+ expect(cachedCommentCount("viewer", 42)).toBe(2);++ context.listComments.mockResolvedValue({+ items: [{ commentId: "parent", deleted: true, reactions: [] }],+ });+ await loadCurrentComments("viewer", "friend", 42);+ expect(cachedCommentCount("viewer", 42)).toBe(0);+});++test("uses fresh feed and profile counts after other people comment or delete", async () => {+ context.listComments.mockResolvedValue({ items: [] });+ await loadCurrentComments("viewer", "friend", 42);++ context.listFeed.mockResolvedValue({ items: [post(3)] });+ await loadCurrentFeedPage("viewer");+ expect(cachedCommentCount("viewer", 42)).toBe(3);++ context.listPosts.mockResolvedValue({ items: [post(1)] });+ await loadCurrentSpaceProfilePostsPage("friend", "viewer");+ expect(cachedCommentCount("viewer", 42)).toBe(1);+});++test("isolates viewers and posts and clears counts on logout", async () => {+ context.listFeed.mockResolvedValue({ items: [post(2)] });+ await loadCurrentFeedPage("viewer");+ expect(cachedCommentCount("other-viewer", 42)).toBeUndefined();+ expect(cachedCommentCount("viewer", 43)).toBeUndefined();++ clearCommentCounts();+ expect(cachedCommentCount("viewer", 42)).toBeUndefined();+});diff --git a/web/apps/space/tests/comments.test.ts b/web/apps/space/tests/comments.test.tsnew file mode 100644index 0000000000..7f747ddfde--- /dev/null+++ b/web/apps/space/tests/comments.test.ts@@ -0,0 +1,255 @@+import { expect, test } from "vitest";+import type { SpaceComment, SpaceNotification } from "../src/services/space";+import {+ commentNotificationText,+ commentReactionPreview,+ commentThreads,+ groupCommentReactions,+ validateCommentReplyTarget,+ type CommentReplyTarget,+} from "../src/utils/comments";++const comment = (+ commentId: string,+ second: number,+ parentId = "",+ replyToId = "",+): SpaceComment => ({+ commentId,+ unreadNotificationIds: [],+ parentId,+ replyToId,+ author: {+ id: commentId,+ username: commentId,+ fullName: commentId,+ friendsCount: 0,+ },+ text: commentId,+ createdAt: `2026-10-16T10:00:${String(second).padStart(2, "0")}Z`,+ deleted: false,+ canDelete: false,+ reactions: [],+});++const reaction = (+ id: string,+ emoji: string,+ isOwn = false,+): SpaceComment["reactions"][number] => ({+ actor: { id, username: id, fullName: id, friendsCount: 0 },+ emoji,+ isOwn,+});++test.each([+ [[], []],+ [["โค๏ธ"], ["โค๏ธ"]],+ [+ ["โค๏ธ", "โค๏ธ"],+ ["โค๏ธ", "โค๏ธ"],+ ],+ [+ ["โค๏ธ", "โค๏ธ", "โค๏ธ", "โค๏ธ", "โค๏ธ"],+ ["โค๏ธ", "โค๏ธ", "โค๏ธ"],+ ],+ [+ ["โค๏ธ", "๐"],+ ["โค๏ธ", "๐"],+ ],+ [+ ["โค๏ธ", "๐", "โค๏ธ"],+ ["โค๏ธ", "โค๏ธ", "๐"],+ ],+ [+ ["โค๏ธ", "๐", "๐", "โค๏ธ", "๐"],+ ["๐", "๐", "โค๏ธ"],+ ],+ [+ ["โค๏ธ", "๐", "โค๏ธ", "๐", "โค๏ธ"],+ ["โค๏ธ", "๐", "๐"],+ ],+ [+ ["โค๏ธ", "๐", "๐", "๐ฎ", "๐ฎ"],+ ["๐ฎ", "โค๏ธ", "๐"],+ ],+])("reaction preview for %j is %j", (emojis, expected) => {+ expect(+ commentReactionPreview(+ emojis.map((emoji, index) => reaction(String(index), emoji)),+ ),+ ).toEqual(expected);+});++test("reactions stay grouped by emoji with your group and your row first", () => {+ const reactions = [+ reaction("alice", "โค๏ธ"),+ reaction("bob", "๐"),+ reaction("carol", "๐"),+ reaction("dave", "โค๏ธ"),+ reaction("you", "๐", true),+ reaction("eve", "๐"),+ reaction("frank", "๐"),+ ];+ const original = [...reactions];+ expect(+ groupCommentReactions(reactions).map(({ actor }) => actor.id),+ ).toEqual(["you", "bob", "eve", "alice", "dave", "carol", "frank"]);+ expect(reactions).toEqual(original);+});++test("removing your reaction restores first-appearance emoji group order", () => {+ const reactions = [+ reaction("alice", "โค๏ธ"),+ reaction("bob", "๐"),+ reaction("you", "๐", true),+ reaction("carol", "โค๏ธ"),+ ].filter(({ isOwn }) => !isOwn);+ expect(+ groupCommentReactions(reactions).map(({ actor }) => actor.id),+ ).toEqual(["alice", "carol", "bob"]);+ expect(groupCommentReactions([])).toEqual([]);+});++test.each([+ ["comment", "owner", "friend", "Commented on your post"],+ ["comment", "viewer", "friend", "Commented on @bob's post"],+ ["comment", "viewer", "owner", "Commented on their post"],+ ["comment_reply", "owner", "friend", "Replied to your comment"],+ ["comment_reply", "viewer", "friend", "Replied to your comment"],+ ["comment_reply", "viewer", "owner", "Replied to your comment"],+ ["comment_reaction", "owner", "friend", "Reacted to your comment"],+ ["comment_reaction", "viewer", "friend", "Reacted to your comment"],+ ["comment_reaction", "viewer", "owner", "Reacted to your comment"],+])(+ "%s names the post for viewer %s and actor %s",+ (kind, viewer, actor, expected) => {+ const notification: SpaceNotification = {+ id: "notification",+ notificationIds: ["notification"],+ kind,+ postSpaceId: "owner",+ postOwnerSlug: "bob",+ postId: 42,+ commentId: "reply",+ actors: [+ {+ id: actor,+ spaceId: actor,+ username: "alice",+ fullName: "Alice",+ friendsCount: 0,+ },+ ],+ actorCount: 1,+ createdAtMs: 0,+ read: false,+ };+ expect(commentNotificationText(notification, viewer)).toBe(expected);+ },+);++test("comments are chronological with replies grouped under their root", () => {+ const entries = [+ comment("second", 2),+ comment("reply2", 4, "first", "reply1"),+ comment("first", 1),+ comment("reply1", 3, "first", "first"),+ ];+ const threads = commentThreads(entries);+ expect(threads.map((thread) => thread.comment.commentId)).toEqual([+ "first",+ "second",+ ]);+ expect(threads[0]?.replies.map((reply) => reply.commentId)).toEqual([+ "reply1",+ "reply2",+ ]);+ expect(threads[0]?.replies[1]?.replyToId).toBe("reply1");+ expect(entries[0]?.commentId).toBe("second");+});++test("deleted roots and their replies leave no visible thread", () => {+ const root = { ...comment("root", 1), text: undefined, deleted: true };+ expect(commentThreads([comment("reply", 2, "root", "root"), root])).toEqual(+ [],+ );+});++test("deleted reply branches disappear without hiding sibling replies", () => {+ const root = comment("root", 1);+ const deleted = { ...comment("deleted", 2, "root", "root"), deleted: true };+ const descendant = {+ ...comment("descendant", 3, "root", "deleted"),+ deleted: true,+ };+ const reply = comment("reply", 4, "root", "root");+ expect(commentThreads([root, deleted, descendant, reply])).toEqual([+ { comment: root, replies: [reply] },+ ]);+});++test("refresh preserves the selected reply without retaining profile metadata", () => {+ const target: CommentReplyTarget = {+ status: "selected",+ commentId: "reply",+ };+ const entries = [comment("root", 1), comment("reply", 2, "root", "root")];+ expect(validateCommentReplyTarget(target, entries)).toEqual(target);+ entries[1]!.author = { ...entries[1]!.author!, fullName: "" };+ expect(validateCommentReplyTarget(target, entries)).toEqual(target);+ expect(validateCommentReplyTarget(undefined, entries)).toBeUndefined();+});++test("a reply target becomes unavailable when its root is deleted", () => {+ const target: CommentReplyTarget = {+ status: "selected",+ commentId: "reply",+ };+ const root = {+ ...comment("root", 1),+ text: undefined,+ author: undefined,+ deleted: true,+ };+ expect(+ validateCommentReplyTarget(target, [+ root,+ comment("reply", 2, "root", "root"),+ ]),+ ).toEqual({ status: "unavailable" });+ expect(+ validateCommentReplyTarget({ status: "selected", commentId: "root" }, [+ root,+ ]),+ ).toEqual({ status: "unavailable" });+});++test.each(["missing", "deleted", "root-missing"])(+ "%s reply targets require an explicit choice before sending a new comment",+ (state) => {+ const target: CommentReplyTarget = {+ status: "selected",+ commentId: "reply",+ };+ const root = comment("root", 1);+ const reply = {+ ...comment("reply", 2, "root", "root"),+ deleted: state == "deleted",+ };+ const entries =+ state == "missing"+ ? [root]+ : state == "root-missing"+ ? [reply]+ : [root, reply];+ const invalidated = validateCommentReplyTarget(target, entries);+ expect(invalidated).toEqual({ status: "unavailable" });+ expect(+ validateCommentReplyTarget(invalidated, [+ comment("root", 1),+ comment("reply", 2, "root", "root"),+ ]),+ ).toEqual(invalidated);+ },+);diff --git a/web/apps/space/tests/notification-avatars.test.ts b/web/apps/space/tests/notification-avatars.test.tsindex dec26b25ec..65884f4643 100644--- a/web/apps/space/tests/notification-avatars.test.ts+++ b/web/apps/space/tests/notification-avatars.test.ts@@ -43,6 +43,7 @@ const context = {downloadSpaceAvatar: vi.fn(),listNotifications: vi.fn(),listConversations: vi.fn(),+ listSpaceFriends: vi.fn(),};beforeEach(() => {@@ -219,3 +220,78 @@ test("already hydrated avatars do not start another lookup or download", async (expect(cachedSpaceMediaBlobURLIfPresent).not.toHaveBeenCalled();expect(ensureCurrentSpaceContext).not.toHaveBeenCalled();});++test("nonfriend discussion actors never restore a cached private avatar", async () => {+ vi.mocked(cachedSpaceMediaBlobURLIfPresent).mockResolvedValue(+ "blob:old-friend-avatar",+ );+ context.listNotifications.mockResolvedValue({+ items: [+ {+ notificationId: "reply-1",+ notificationIds: ["reply-1"],+ kind: "comment_reply",+ actors: [{ spaceId: "former-friend", spaceSlug: "sam" }],+ actorCount: 1,+ postId: 42,+ postSpaceId: "post-owner",+ postOwnerSlug: "bob",+ commentId: "comment-1",+ createdAt,+ unread: true,+ },+ ],+ });+ const notification = (await loadCurrentNotifications("viewer-space"))+ .items[0]!;+ expect(notification.actors[0]?.fullName).toBe("sam");+ expect(notification.actors[0]?.avatarUrl).toBeNull();+ expect(notification.postSpaceId).toBe("post-owner");+ expect(notification.postOwnerSlug).toBe("bob");+ expect(notification.commentId).toBe("comment-1");+ expect(cachedSpaceMediaBlobURLIfPresent).not.toHaveBeenCalled();+});++test("comment groups preserve distinct actors and use the post owner's available name", async () => {+ context.listSpaceFriends.mockResolvedValue([+ {+ friend: {+ spaceId: "post-owner",+ spaceSlug: "bob",+ profile: { fullName: "Bob Smith" },+ },+ },+ ]);+ context.listNotifications.mockResolvedValue({+ items: [+ {+ notificationId: "comment-3",+ notificationIds: ["comment-1", "comment-2", "comment-3"],+ kind: "comment",+ actors: [+ actor,+ {+ spaceId: "second",+ spaceSlug: "sam",+ profile: { fullName: "Sam" },+ },+ ],+ actorCount: 2,+ postId: 42,+ postSpaceId: "post-owner",+ postOwnerSlug: "bob",+ commentId: "latest-comment",+ createdAt,+ unread: true,+ },+ ],+ });+ const page = await loadCurrentNotifications("comment-group-viewer");+ expect(page.items[0]).toMatchObject({+ postOwnerName: "Bob Smith",+ actorCount: 2,+ commentId: "latest-comment",+ notificationIds: ["comment-1", "comment-2", "comment-3"],+ actors: [{ fullName: "Maya Patel" }, { fullName: "Sam" }],+ });+});diff --git a/web/apps/space/tests/notifications.test.ts b/web/apps/space/tests/notifications.test.tsnew file mode 100644index 0000000000..568089e085--- /dev/null+++ b/web/apps/space/tests/notifications.test.ts@@ -0,0 +1,103 @@+import { expect, test } from "vitest";+import type { SpaceNotification } from "../src/services/space";+import { commentNotificationText } from "../src/utils/comments";+import { notificationGroupKey } from "../src/utils/notifications";++const notification: SpaceNotification = {+ id: "latest",+ notificationIds: ["latest", "older"],+ kind: "comment",+ actors: [+ {+ id: "owner",+ spaceId: "owner",+ username: "anand",+ fullName: "Anand",+ friendsCount: 0,+ },+ {+ id: "friend",+ spaceId: "friend",+ username: "sam",+ fullName: "Sam",+ friendsCount: 0,+ },+ ],+ actorCount: 2,+ postId: 42,+ postSpaceId: "owner",+ postOwnerSlug: "anand",+ postOwnerName: "Anand Baburajan",+ createdAtMs: 0,+ read: false,+};++test("a group names the post owner even when they are its latest commenter", () => {+ expect(commentNotificationText(notification, "viewer")).toBe(+ "Commented on Anand's post",+ );+ expect(+ commentNotificationText({ ...notification, actorCount: 1 }, "viewer"),+ ).toBe("Commented on their post");+ expect(commentNotificationText(notification, "owner")).toBe(+ "Commented on your post",+ );+});++test.each(["comment", "post_like"])(+ "%s keeps its group across new events and pagination",+ (kind) => {+ expect(notificationGroupKey({ ...notification, kind })).toBe(+ notificationGroupKey({+ ...notification,+ kind,+ id: "older",+ commentId: "older-comment",+ }),+ );+ expect(notificationGroupKey({ ...notification, kind })).not.toBe(+ notificationGroupKey({ ...notification, kind, postId: 43 }),+ );+ },+);++test("reactions group by the exact comment, independently of replies", () => {+ const reaction = {+ ...notification,+ kind: "comment_reaction",+ commentId: "target",+ };+ expect(notificationGroupKey(reaction)).toBe(+ notificationGroupKey({ ...reaction, id: "older" }),+ );+ expect(notificationGroupKey(reaction)).not.toBe(+ notificationGroupKey({ ...reaction, commentId: "another-target" }),+ );+ expect(notificationGroupKey(reaction)).not.toBe(+ notificationGroupKey({+ ...reaction,+ kind: "comment_reply",+ commentId: "reply",+ replyToId: "target",+ }),+ );+});++test("replies to the same comment retain their group when the newest reply changes", () => {+ const reply = {+ ...notification,+ kind: "comment_reply",+ commentId: "newest-reply",+ replyToId: "target",+ };+ expect(notificationGroupKey(reply)).toBe(+ notificationGroupKey({+ ...reply,+ id: "older",+ commentId: "older-reply",+ }),+ );+ expect(notificationGroupKey(reply)).not.toBe(+ notificationGroupKey({ ...reply, replyToId: "another-target" }),+ );+});diff --git a/web/packages/wasm/space/index.ts b/web/packages/wasm/space/index.tsindex f1d5e686a6..b703ce32d7 100644--- a/web/packages/wasm/space/index.ts+++ b/web/packages/wasm/space/index.ts@@ -7,6 +7,9 @@ import type {} from "./pkg/ente_space_wasm";export type {+ Comment,+ CommentPage,+ CommentReaction,DecryptedSpaceProfile,MessageConversationActivity,MessageResponse,