Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Add Space notifications and persistent app navigation

Anand Baburajan12cf70259115
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index 3af45a77b5..46c606c912 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -335,6 +335,50 @@ pub struct PostPage {
next_cursor: String,
}
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct Notification {
+ notification_id: String,
+ kind: String,
+ actors: Vec<SpaceActorResponse>,
+ actor_count: i64,
+ post_id: Option<i64>,
+ friend_request_id: Option<i64>,
+ created_at: String,
+ unread: bool,
+}
+
+#[derive(Serialize, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct NotificationPage {
+ latest_post_created_at: Option<String>,
+ items: Vec<Notification>,
+ next_cursor: String,
+}
+
+impl From<ente_space::NotificationPage> for NotificationPage {
+ fn from(page: ente_space::NotificationPage) -> Self {
+ Self {
+ latest_post_created_at: page.latest_post_created_at,
+ items: page
+ .items
+ .into_iter()
+ .map(|item| Notification {
+ notification_id: item.notification_id,
+ kind: item.kind,
+ actors: item.actors.into_iter().map(Into::into).collect(),
+ actor_count: item.actor_count,
+ post_id: item.post_id,
+ friend_request_id: item.friend_request_id,
+ created_at: item.created_at,
+ unread: item.unread,
+ })
+ .collect(),
+ next_cursor: page.next_cursor,
+ }
+ }
+}
+
#[derive(Serialize, Tsify)]
#[serde(rename_all = "camelCase")]
pub struct MessageResponse {
@@ -442,7 +486,6 @@ impl From<ente_space::ConversationChatSummary> for ConversationChatSummaryRespon
#[serde(rename_all = "camelCase")]
pub struct ConversationsResponse {
friends: Vec<SpaceFriendResponse>,
- pending_requests: Vec<SpaceFriendRequestResponse>,
chat_summaries: BTreeMap<String, ConversationChatSummaryResponse>,
latest_post_created_at: Option<String>,
}
@@ -451,11 +494,6 @@ impl From<ente_space::Conversations> for ConversationsResponse {
fn from(conversations: ente_space::Conversations) -> Self {
Self {
friends: conversations.friends.into_iter().map(Into::into).collect(),
- pending_requests: conversations
- .pending_requests
- .into_iter()
- .map(Into::into)
- .collect(),
chat_summaries: conversations
.chat_summaries
.into_iter()
@@ -1148,6 +1186,39 @@ impl SpaceAccountCtxHandle {
PostPage::from(page).into_js().map_err(Into::into)
}
+ #[wasm_bindgen(js_name = listNotifications)]
+ pub async fn list_notifications(
+ &self,
+ space_id: String,
+ cursor: Option<String>,
+ limit: Option<i32>,
+ ) -> Result<<NotificationPage as Tsify>::JsType, Error> {
+ NotificationPage::from(
+ self.inner
+ .list_notifications(&space_id, cursor, limit)
+ .await?,
+ )
+ .into_js()
+ .map_err(Into::into)
+ }
+
+ #[wasm_bindgen(js_name = notificationsUnread)]
+ pub async fn notifications_unread(&self, space_id: String) -> Result<bool, Error> {
+ Ok(self.inner.notifications_unread(&space_id).await?)
+ }
+
+ #[wasm_bindgen(js_name = markNotificationItemsRead)]
+ pub async fn mark_notification_items_read(
+ &self,
+ space_id: String,
+ notification_ids: Vec<String>,
+ ) -> Result<(), Error> {
+ self.inner
+ .mark_notification_items_read(&space_id, notification_ids)
+ .await?;
+ Ok(())
+ }
+
#[wasm_bindgen(js_name = unreadStatus)]
pub async fn unread_status(
&self,
@@ -1391,9 +1462,12 @@ impl SpaceAccountCtxHandle {
&self,
sender_space_id: String,
space_id: String,
- ) -> Result<<MessageResponse as Tsify>::JsType, Error> {
- let message = self.inner.send_poke(&sender_space_id, &space_id).await?;
- MessageResponse::from(message).into_js().map_err(Into::into)
+ client_request_id: String,
+ ) -> Result<(), Error> {
+ Ok(self
+ .inner
+ .send_poke(&sender_space_id, &space_id, &client_request_id)
+ .await?)
}
#[wasm_bindgen(js_name = replyToMessage)]
diff --git a/rust/crates/space/src/client/messages.rs b/rust/crates/space/src/client/messages.rs
index 82d9c6c0ef..b895d21164 100644
--- a/rust/crates/space/src/client/messages.rs
+++ b/rust/crates/space/src/client/messages.rs
@@ -18,9 +18,6 @@ use crate::transport::{
};
use ente_core::b64;
-const MESSAGE_NOTIFICATION_KIND_POKE: &str = "poke";
-const POKE_MESSAGE_TEXT: &str = "Poked";
-
impl AccountSpaceCtx {
pub async fn list_conversations(&self, space_id: &str) -> Result<Conversations> {
let path = format!("/spaces/{space_id}/conversations");
@@ -38,18 +35,51 @@ impl AccountSpaceCtx {
}
let mut chat_summaries = std::collections::BTreeMap::new();
for (friend_space_id, summary) in response.chat_summaries {
- chat_summaries.insert(
- friend_space_id,
- self.open_conversation_summary(space_id, summary).await?,
- );
+ let mut summary = self.open_conversation_summary(space_id, summary).await?;
+ if summary.latest_activity.kind == MESSAGE_KIND_POKE {
+ let mut cursor = None;
+ let message = loop {
+ let page = self
+ .list_message_thread(space_id, &friend_space_id, cursor, Some(100))
+ .await?;
+ if let Some(message) = page
+ .items
+ .into_iter()
+ .find(|item| !matches!(item.content, Ok(None)))
+ {
+ break Some(message);
+ }
+ if page.next_cursor.is_empty() {
+ break None;
+ }
+ cursor = Some(page.next_cursor);
+ };
+ let Some(message) = message else {
+ continue;
+ };
+ let outgoing = message.sender_space_id == space_id;
+ let activity_type = if message.kind == MESSAGE_KIND_POST_REPLY && !outgoing {
+ "post_reply"
+ } else {
+ "message"
+ };
+ summary.latest_activity = MessageActivity {
+ id: format!("{activity_type}:{}", message.message_id),
+ activity_type: activity_type.into(),
+ kind: message.kind,
+ created_at: message.created_at,
+ outgoing,
+ message_id: Some(message.message_id),
+ content: message.content,
+ reaction: message.reaction,
+ post_id: message.reply_post_id,
+ post_space_id: message.reply_post_id.map(|_| message.recipient_space_id),
+ };
+ }
+ chat_summaries.insert(friend_space_id, summary);
}
Ok(Conversations {
friends,
- pending_requests: response
- .pending_requests
- .into_iter()
- .map(Into::into)
- .collect(),
chat_summaries,
latest_post_created_at: response.latest_post_created_at,
})
@@ -62,31 +92,40 @@ impl AccountSpaceCtx {
cursor: Option<String>,
limit: Option<i32>,
) -> Result<MessagePage> {
- let mut query = Vec::new();
- if let Some(value) = cursor.filter(|value| !value.trim().is_empty()) {
- query.push(("cursor", value));
- }
- if let Some(value) = limit {
- query.push(("limit", value.to_string()));
- }
- let path = format!("/spaces/{viewer_space_id}/friends/{space_id}/messages");
- let page: MessagePageResponse = self
- .api()
- .get(&path)
- .query(&query)
- .send()
- .await?
- .error_for_status()?
- .json()
- .await?;
- let mut items = Vec::with_capacity(page.items.len());
- for message in page.items {
- items.push(self.open_message(viewer_space_id, message).await?);
+ let mut cursor = cursor;
+ loop {
+ let mut query = Vec::new();
+ if let Some(value) = cursor.filter(|value| !value.trim().is_empty()) {
+ query.push(("cursor", value));
+ }
+ if let Some(value) = limit {
+ query.push(("limit", value.to_string()));
+ }
+ let path = format!("/spaces/{viewer_space_id}/friends/{space_id}/messages");
+ let page: MessagePageResponse = self
+ .api()
+ .get(&path)
+ .query(&query)
+ .send()
+ .await?
+ .error_for_status()?
+ .json()
+ .await?;
+ let mut items = Vec::with_capacity(page.items.len());
+ for message in page.items {
+ let message = self.open_message(viewer_space_id, message).await?;
+ if message.kind != MESSAGE_KIND_POKE {
+ items.push(message);
+ }
+ }
+ if !items.is_empty() || page.next_cursor.is_empty() {
+ return Ok(MessagePage {
+ items,
+ next_cursor: page.next_cursor,
+ });
+ }
+ cursor = Some(page.next_cursor);
}
- Ok(MessagePage {
- items,
- next_cursor: page.next_cursor,
- })
}
async fn open_message(
@@ -97,7 +136,7 @@ impl AccountSpaceCtx {
let mut kind = message.kind.clone();
let content = if message.is_deleted {
Ok(None)
- } else if kind == "post_like" || kind == "friend_added" {
+ } else if kind == "friend_added" {
Ok(Some(MessageContent {
text: message.text.clone(),
reply_object_key: None,
@@ -179,6 +218,7 @@ impl AccountSpaceCtx {
activity.kind = MESSAGE_KIND_POKE.to_owned();
}
}
+ unread_activities.retain(|activity| activity.kind != MESSAGE_KIND_POKE);
Ok(ConversationChatSummary {
latest_activity,
unread_activities,
@@ -261,21 +301,6 @@ impl AccountSpaceCtx {
.await
}
- pub async fn send_poke(&self, sender_space_id: &str, space_id: &str) -> Result<Message> {
- self.send_direct_message(
- sender_space_id,
- space_id,
- MessagePayload {
- version: 1,
- kind: MESSAGE_KIND_POKE.to_owned(),
- text: POKE_MESSAGE_TEXT.to_owned(),
- reply_object_key: None,
- },
- Some(MESSAGE_NOTIFICATION_KIND_POKE),
- )
- .await
- }
-
async fn send_direct_message(
&self,
sender_space_id: &str,
diff --git a/rust/crates/space/src/client/mod.rs b/rust/crates/space/src/client/mod.rs
index 9cc5e9f4a9..3fd3108310 100644
--- a/rust/crates/space/src/client/mod.rs
+++ b/rust/crates/space/src/client/mod.rs
@@ -5,6 +5,8 @@ mod keys;
mod links;
mod media;
mod messages;
+mod notifications;
+mod pokes;
mod posts;
mod profiles;
mod reactions;
diff --git a/rust/crates/space/src/client/notifications.rs b/rust/crates/space/src/client/notifications.rs
new file mode 100644
index 0000000000..a47ca59f99
--- /dev/null
+++ b/rust/crates/space/src/client/notifications.rs
@@ -0,0 +1,168 @@
+use super::{AccountSpaceCtx, retain_content_error};
+use crate::error::Result;
+use crate::models::{Notification, NotificationPage, SpaceActor};
+use crate::transport::{NotificationPageResponse, NotificationUnreadResponse};
+
+impl AccountSpaceCtx {
+ pub async fn list_notifications(
+ &self,
+ space_id: &str,
+ cursor: Option<String>,
+ limit: Option<i32>,
+ ) -> Result<NotificationPage> {
+ let mut query = Vec::new();
+ if let Some(value) = cursor.filter(|value| !value.is_empty()) {
+ query.push(("cursor", value));
+ }
+ if let Some(value) = limit {
+ query.push(("limit", value.to_string()));
+ }
+ let path = format!("/spaces/{space_id}/notifications");
+ let page: NotificationPageResponse = self
+ .api()
+ .get(&path)
+ .query(&query)
+ .send()
+ .await?
+ .error_for_status()?
+ .json()
+ .await?;
+ if page.items.iter().any(|item| item.kind != "friend_request") {
+ let shares = self.list_decrypted_friend_shares_cached(space_id).await?;
+ if page
+ .items
+ .iter()
+ .flat_map(|item| &item.actors)
+ .any(|actor| {
+ !actor.encrypted_profile.is_empty()
+ && !shares.iter().any(|share| share.space_id == actor.space_id)
+ })
+ {
+ self.clear_friend_share_cache()?;
+ self.list_decrypted_friend_shares_cached(space_id).await?;
+ }
+ }
+ let mut items = Vec::with_capacity(page.items.len());
+ for item in page.items {
+ let mut actors = Vec::with_capacity(item.actors.len());
+ for actor in item.actors {
+ let profile = retain_content_error(self.decrypt_actor_profile(&actor).await)?;
+ actors.push(SpaceActor::from_response(actor, profile));
+ }
+ items.push(Notification {
+ notification_id: item.notification_id,
+ kind: item.kind,
+ actors,
+ actor_count: item.actor_count,
+ post_id: item.post_id,
+ friend_request_id: item.friend_request_id,
+ created_at: item.created_at,
+ unread: item.unread,
+ });
+ }
+ Ok(NotificationPage {
+ latest_post_created_at: page.latest_post_created_at,
+ items,
+ next_cursor: page.next_cursor,
+ })
+ }
+
+ pub async fn notifications_unread(&self, space_id: &str) -> Result<bool> {
+ let path = format!("/spaces/{space_id}/notifications/unread");
+ let response: NotificationUnreadResponse = self
+ .api()
+ .get(&path)
+ .send()
+ .await?
+ .error_for_status()?
+ .json()
+ .await?;
+ Ok(response.unread)
+ }
+
+ pub async fn mark_notification_items_read(
+ &self,
+ space_id: &str,
+ notification_ids: Vec<String>,
+ ) -> Result<()> {
+ let path = format!("/spaces/{space_id}/notifications/read");
+ self.api()
+ .post(&path)
+ .json(&serde_json::json!({"notificationIds": notification_ids}))
+ .send()
+ .await?
+ .error_for_status()?;
+ Ok(())
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::client::test_support::test_account_ctx;
+ use mockito::Matcher;
+ use serde_json::json;
+
+ #[tokio::test]
+ async fn pending_request_notifications_do_not_require_friend_access() {
+ 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":"request-1","kind":"friend_request","actors":[{"spaceId":"requester","spaceSlug":"maya"}],"actorCount":1,"friendRequestId":7,"createdAt":"2026-10-07T10:00:00Z","unread":true}]}).to_string())
+ .create_async().await;
+ let notifications = ctx
+ .list_notifications("space_owner_main", None, None)
+ .await
+ .unwrap();
+ assert_eq!(notifications.items[0].friend_request_id, Some(7));
+ assert_eq!(notifications.items[0].post_id, None);
+ assert_eq!(notifications.items[0].actors[0].space_slug, "maya");
+ page.assert_async().await;
+ }
+
+ #[tokio::test]
+ async fn notification_feed_and_read_state_use_separate_endpoints() {
+ 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")
+ .match_query(Matcher::AllOf(vec![Matcher::UrlEncoded("cursor".into(), "1000:wnot_a".into()), Matcher::UrlEncoded("limit".into(), "20".into())]))
+ .match_header("x-space-session-token", "space-session-token")
+ .with_body(json!({"items": [{"notificationId":"wnot_b", "kind":"post_like", "actors":[{"spaceId":"friend", "spaceSlug":"bob"},{"spaceId":"friend2", "spaceSlug":"maya"}], "actorCount":50, "unread":true, "postId":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 unread = server
+ .mock("GET", "/spaces/space_owner_main/notifications/unread")
+ .with_body("{\"unread\":true}")
+ .create_async()
+ .await;
+ let read = server
+ .mock("POST", "/spaces/space_owner_main/notifications/read")
+ .match_body(Matcher::Json(json!({"notificationIds":["wnot_b"]})))
+ .with_status(200)
+ .create_async()
+ .await;
+ let notifications = ctx
+ .list_notifications("space_owner_main", Some("1000:wnot_a".into()), Some(20))
+ .await
+ .unwrap();
+ assert_eq!(notifications.items.len(), 1);
+ assert_eq!(notifications.items[0].actors[0].space_slug, "bob");
+ assert_eq!(notifications.items[0].post_id, Some(42));
+ assert_eq!(notifications.items[0].actors[1].space_slug, "maya");
+ assert_eq!(notifications.items[0].actors.len(), 2);
+ assert_eq!(notifications.items[0].actor_count, 50);
+ assert!(notifications.items[0].unread);
+ assert!(notifications.next_cursor.is_empty());
+ assert!(ctx.notifications_unread("space_owner_main").await.unwrap());
+ ctx.mark_notification_items_read("space_owner_main", vec!["wnot_b".into()])
+ .await
+ .unwrap();
+ page.assert_async().await;
+ shares.assert_async().await;
+ unread.assert_async().await;
+ read.assert_async().await;
+ }
+}
diff --git a/rust/crates/space/src/client/pokes.rs b/rust/crates/space/src/client/pokes.rs
new file mode 100644
index 0000000000..6e03e6db4f
--- /dev/null
+++ b/rust/crates/space/src/client/pokes.rs
@@ -0,0 +1,20 @@
+use super::AccountSpaceCtx;
+use crate::error::Result;
+
+impl AccountSpaceCtx {
+ pub async fn send_poke(
+ &self,
+ sender_space_id: &str,
+ space_id: &str,
+ client_request_id: &str,
+ ) -> Result<()> {
+ let path = format!("/spaces/{sender_space_id}/friends/{space_id}/pokes");
+ self.api()
+ .post(&path)
+ .json(&serde_json::json!({"clientRequestId": client_request_id}))
+ .send()
+ .await?
+ .error_for_status()?;
+ Ok(())
+ }
+}
diff --git a/rust/crates/space/src/client/posts.rs b/rust/crates/space/src/client/posts.rs
index baa05c3a83..e5a3be3571 100644
--- a/rust/crates/space/src/client/posts.rs
+++ b/rust/crates/space/src/client/posts.rs
@@ -186,14 +186,23 @@ impl AccountSpaceCtx {
pub async fn unread_status(&self, space_id: &str) -> Result<SpaceUnreadStatusResponse> {
let path = format!("/spaces/{space_id}/unread");
- Ok(self
+ let mut status: SpaceUnreadStatusResponse = self
.api()
.get(&path)
.send()
.await?
.error_for_status()?
.json()
- .await?)
+ .await?;
+ if status.notifications_unread {
+ status.notifications_unread = self
+ .list_conversations(space_id)
+ .await?
+ .chat_summaries
+ .values()
+ .any(|summary| !summary.unread_activities.is_empty());
+ }
+ Ok(status)
}
pub async fn mark_notifications_read(
diff --git a/rust/crates/space/src/client/tests.rs b/rust/crates/space/src/client/tests.rs
index b22e406d32..d0667de12d 100644
--- a/rust/crates/space/src/client/tests.rs
+++ b/rust/crates/space/src/client/tests.rs
@@ -82,8 +82,8 @@ async fn message_thread_keeps_content_failures_local_to_each_message() {
"regular",
br#"{"version":1,"kind":"poke","text":"Poked"}"#,
);
- let mut event = message("event", "post_like", b"");
- event.text = "Liked your post".into();
+ let mut event = message("event", "friend_added", b"");
+ event.text = "You are now friends".into();
let mut deleted = message("deleted", "regular", b"");
deleted.is_deleted = true;
let corrupt = message("corrupt", "regular", b"not-json");
@@ -105,28 +105,27 @@ async fn message_thread_keeps_content_failures_local_to_each_message() {
.await
.unwrap();
assert_eq!(opened.next_cursor, "next");
- assert_eq!(opened.items.len(), 6);
+ assert_eq!(opened.items.len(), 5);
assert_eq!(content(&opened.items[0]).text, "hello");
assert!(opened.items[0].reaction.is_err());
assert_eq!(
content(&opened.items[0]).reply_object_key.as_deref(),
Some("photo")
);
- assert_eq!(opened.items[1].kind, "poke");
- assert_eq!(content(&opened.items[1]).text, "Poked");
- assert_eq!(opened.items[2].kind, "post_like");
- assert_eq!(content(&opened.items[2]).text, "Liked your post");
- assert!(opened.items[3].content.as_ref().unwrap().is_none());
+ assert!(opened.items.iter().all(|item| item.kind != "poke"));
+ assert_eq!(opened.items[1].kind, "friend_added");
+ assert_eq!(content(&opened.items[1]).text, "You are now friends");
+ assert!(opened.items[2].content.as_ref().unwrap().is_none());
assert!(matches!(
- &opened.items[4].content,
+ &opened.items[3].content,
Err(Error::InvalidInput(_))
));
- assert_eq!(content(&opened.items[5]).text, "hello");
+ assert_eq!(content(&opened.items[4]).text, "hello");
request.assert_async().await;
}
#[tokio::test]
-async fn unread_poke_uses_latest_activity_kind() {
+async fn unread_poke_is_hidden_after_identifying_its_kind() {
let server = Server::new_async().await;
let ctx = test_account_ctx(&server.url());
let activity = MessageConversationActivity {
@@ -158,7 +157,7 @@ async fn unread_poke_uses_latest_activity_kind() {
.await
.unwrap();
- assert_eq!(summary.unread_activities[0].kind, "poke");
+ assert!(summary.unread_activities.is_empty());
}
#[tokio::test]
@@ -1826,73 +1825,22 @@ async fn message_actions_use_message_endpoints() {
}
#[tokio::test]
-async fn poke_message_requests_special_notification() {
+async fn pokes_use_their_own_endpoint_and_retry_id() {
let mut server = Server::new_async().await;
- let space_root_key = generate_key();
- let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key);
- let (friend_public_key, _) = generate_keypair().expect("valid friend keypair");
-
- let friends = server
- .mock("GET", "/spaces/space_owner_main/friends")
- .match_header("x-space-session-token", "space-session-token")
- .with_status(200)
- .with_body(
- json!([{
- "friend": {
- "spaceId": "space_friend",
- "spaceSlug": "friend",
- "publicKey": b64::encode(&friend_public_key),
- "keyVersion": 2
- },
- "shareKeyVersion": 2,
- "createdAt": "2026-04-16T00:00:00Z"
- }])
- .to_string(),
- )
- .create_async()
- .await;
+ let ctx = test_account_ctx(&server.url());
let poke = server
.mock(
"POST",
- "/spaces/space_owner_main/friends/space_friend/messages",
+ "/spaces/space_owner_main/friends/space_friend/pokes",
)
.match_header("x-space-session-token", "space-session-token")
- .match_body(Matcher::AllOf(vec![
- Matcher::Regex("\"notificationKind\":\"poke\"".into()),
- Matcher::Regex("\"messageCipher\":\"[^\"]+\"".into()),
- Matcher::Regex("\"senderEncryptedMessageKey\":\"[^\"]+\"".into()),
- Matcher::Regex("\"recipientEncryptedMessageKey\":\"[^\"]+\"".into()),
- ]))
+ .match_body(Matcher::Json(json!({"clientRequestId":"poke-request-1"})))
.with_status(200)
- .with_body_from_request(|request| {
- let body: serde_json::Value = serde_json::from_slice(request.body().unwrap()).unwrap();
- json!({
- "messageId": "wmsg_poke",
- "kind": "regular",
- "senderSpaceId": "space_owner_main",
- "recipientSpaceId": "space_friend",
- "messageCipher": body["messageCipher"],
- "encryptedMessageKey": body["senderEncryptedMessageKey"],
- "liked": false,
- "viewerLiked": false,
- "isDeleted": false,
- "createdAt": "2026-04-16T00:00:00Z",
- "updatedAt": "2026-04-16T00:00:00Z"
- })
- .to_string()
- .into_bytes()
- })
.create_async()
.await;
-
- let message = ctx
- .send_poke("space_owner_main", "space_friend")
+ ctx.send_poke("space_owner_main", "space_friend", "poke-request-1")
.await
- .expect("poke should be sent");
-
- assert_eq!(message.message_id, "wmsg_poke");
- assert_eq!(message.kind, "poke");
- friends.assert_async().await;
+ .unwrap();
poke.assert_async().await;
}
@@ -2455,3 +2403,95 @@ fn build_history_walks_back_versions() {
assert_eq!(history.get(&2), Some(&v2));
assert_eq!(history.get(&1), Some(&v1));
}
+
+#[tokio::test]
+async fn legacy_pokes_are_hidden_from_threads_previews_and_unread_status() {
+ for has_message in [true, false] {
+ let mut server = Server::new_async().await;
+ let ctx = test_account_ctx(&server.url());
+ let key = generate_key();
+ let encrypted_key =
+ b64::encode(&seal_with_public_key(&key, &test_public_key(&ctx)).unwrap());
+ let make_message = |id: &str, kind: &str, created_at: &str| {
+ let cipher = b64::encode(&encrypt_secretbox_payload(&key, &serde_json::to_vec(&json!({"version":1,"kind":kind,"text":if kind == "poke" {"Poked"} else {"Hello"}})).unwrap()).unwrap());
+ json!({"messageId":id,"kind":"regular","senderSpaceId":"space_friend","recipientSpaceId":"space_owner_main","messageCipher":cipher,"encryptedMessageKey":encrypted_key,"liked":false,"viewerLiked":false,"isDeleted":false,"createdAt":created_at,"updatedAt":created_at})
+ };
+ let poke = make_message("poke", "poke", "2026-10-07T12:00:00Z");
+ let message = make_message("message", "regular", "2026-10-06T12:00:00Z");
+ let make_activity = |message: &serde_json::Value| {
+ let mut activity = message.clone();
+ activity["id"] = json!(format!(
+ "message:{}",
+ message["messageId"].as_str().unwrap()
+ ));
+ activity["type"] = json!("message");
+ activity
+ };
+ let mut unread = vec![make_activity(&poke)];
+ if has_message {
+ unread.push(make_activity(&message));
+ }
+ let conversations = server.mock("GET", "/spaces/space_owner_main/conversations")
+ .with_body(json!({"friends":[],"chatSummaries":{"space_friend":{"latestActivity":make_activity(&poke),"unreadActivities":unread}}}).to_string())
+ .expect(2).create_async().await;
+ let first = server
+ .mock(
+ "GET",
+ "/spaces/space_owner_main/friends/space_friend/messages",
+ )
+ .match_query(Matcher::Exact("limit=100".into()))
+ .with_body(json!({"items":[poke],"nextCursor":"older"}).to_string())
+ .expect(2)
+ .create_async()
+ .await;
+ let second = server
+ .mock(
+ "GET",
+ "/spaces/space_owner_main/friends/space_friend/messages",
+ )
+ .match_query(Matcher::AllOf(vec![
+ Matcher::UrlEncoded("cursor".into(), "older".into()),
+ Matcher::UrlEncoded("limit".into(), "100".into()),
+ ]))
+ .with_body(json!({"items":if has_message {vec![message]} else {vec![]}}).to_string())
+ .expect(2)
+ .create_async()
+ .await;
+ let status = server
+ .mock("GET", "/spaces/space_owner_main/unread")
+ .with_body(json!({"notificationsUnread":true}).to_string())
+ .create_async()
+ .await;
+ let result = ctx.list_conversations("space_owner_main").await.unwrap();
+ if has_message {
+ let summary = &result.chat_summaries["space_friend"];
+ assert_eq!(summary.latest_activity.kind, "regular");
+ assert_eq!(
+ summary
+ .latest_activity
+ .content
+ .as_ref()
+ .unwrap()
+ .as_ref()
+ .unwrap()
+ .text,
+ "Hello"
+ );
+ assert_eq!(summary.unread_activities.len(), 1);
+ assert_eq!(summary.unread_activities[0].kind, "regular");
+ } else {
+ assert!(result.chat_summaries.is_empty());
+ }
+ assert_eq!(
+ ctx.unread_status("space_owner_main")
+ .await
+ .unwrap()
+ .notifications_unread,
+ has_message
+ );
+ conversations.assert_async().await;
+ first.assert_async().await;
+ second.assert_async().await;
+ status.assert_async().await;
+ }
+}
diff --git a/rust/crates/space/src/lib.rs b/rust/crates/space/src/lib.rs
index 6ea2785ae5..0f42d3bf7e 100644
--- a/rust/crates/space/src/lib.rs
+++ b/rust/crates/space/src/lib.rs
@@ -15,9 +15,9 @@ pub use error::{Error, Result};
pub use models::{
ConversationChatSummary, Conversations, CreatedSpace, CreatedSpaceLink, DecryptedFriendShare,
DecryptedSpaceProfile, HydratedKeys, Message, MessageActivity, MessageContent, MessagePage,
- MessagePayload, OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput, Post, PostAsset, PostContent,
- PostObjectMetadata, PostPage, PostPhoto, PostVideo, SpaceActor, SpaceFriend,
- SpaceFriendRequest, SpaceProfile, SpaceSentFriendRequest,
+ MessagePayload, Notification, NotificationPage, OpenAccountSpaceCtxInput,
+ OpenSpaceLinkCtxInput, Post, PostAsset, PostContent, PostObjectMetadata, PostPage, PostPhoto,
+ PostVideo, SpaceActor, SpaceFriend, SpaceFriendRequest, SpaceProfile, SpaceSentFriendRequest,
};
pub use transport::{
ConversationChatSummaryResponse, ConversationsResponse, EntityKeyPayload,
diff --git a/rust/crates/space/src/models.rs b/rust/crates/space/src/models.rs
index 52917ac33f..75dbc3dbdc 100644
--- a/rust/crates/space/src/models.rs
+++ b/rust/crates/space/src/models.rs
@@ -220,6 +220,23 @@ pub struct MessagePage {
pub next_cursor: String,
}
+pub struct Notification {
+ pub notification_id: String,
+ pub kind: String,
+ pub actors: Vec<SpaceActor>,
+ pub actor_count: i64,
+ pub post_id: Option<i64>,
+ pub friend_request_id: Option<i64>,
+ pub created_at: String,
+ pub unread: bool,
+}
+
+pub struct NotificationPage {
+ pub latest_post_created_at: Option<String>,
+ pub items: Vec<Notification>,
+ pub next_cursor: String,
+}
+
pub struct MessageActivity {
pub id: String,
pub activity_type: String,
@@ -240,7 +257,6 @@ pub struct ConversationChatSummary {
pub struct Conversations {
pub friends: Vec<SpaceFriend>,
- pub pending_requests: Vec<SpaceFriendRequest>,
pub chat_summaries: BTreeMap<String, ConversationChatSummary>,
pub latest_post_created_at: Option<String>,
}
diff --git a/rust/crates/space/src/transport.rs b/rust/crates/space/src/transport.rs
index a2e0eba609..0f2af49896 100644
--- a/rust/crates/space/src/transport.rs
+++ b/rust/crates/space/src/transport.rs
@@ -229,8 +229,6 @@ pub struct ConversationChatSummaryResponse {
pub struct ConversationsResponse {
pub friends: Vec<SpaceFriendResponse>,
#[serde(default)]
- pub pending_requests: Vec<SpaceFriendRequestResponse>,
- #[serde(default)]
pub chat_summaries: std::collections::BTreeMap<String, ConversationChatSummaryResponse>,
#[serde(default)]
pub latest_post_created_at: Option<String>,
@@ -678,3 +676,31 @@ pub struct SpaceLookupResponse {
#[serde(default)]
pub public_key: String,
}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NotificationResponse {
+ pub notification_id: String,
+ pub kind: String,
+ pub actors: Vec<SpaceActorResponse>,
+ pub actor_count: i64,
+ pub post_id: Option<i64>,
+ pub friend_request_id: Option<i64>,
+ pub created_at: String,
+ pub unread: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NotificationPageResponse {
+ #[serde(default)]
+ pub latest_post_created_at: Option<String>,
+ pub items: Vec<NotificationResponse>,
+ #[serde(default)]
+ pub next_cursor: String,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct NotificationUnreadResponse {
+ pub unread: bool,
+}
diff --git a/rust/crates/space/tests/space.rs b/rust/crates/space/tests/space.rs
index 165ce21f87..29cf614920 100644
--- a/rust/crates/space/tests/space.rs
+++ b/rust/crates/space/tests/space.rs
@@ -34,11 +34,72 @@ async fn request_and_confirm_friend(
.iter()
.find(|request| request.requester.space_id == requester_space_id)
.expect("friend request should be visible to target");
+ let pending = target_ctx
+ .list_notifications(target_space_id, None, None)
+ .await
+ .expect("request notification should load");
+ let notification = pending
+ .items
+ .iter()
+ .find(|item| item.friend_request_id == Some(request.request_id))
+ .expect("pending request should be in notifications");
+ assert_eq!(notification.kind, "friend_request");
+ let request_notification_id = notification.notification_id.clone();
+ assert!(notification.actors[0].profile.as_ref().unwrap().is_none());
+ assert!(notification.actors[0].avatar.is_none());
+ assert!(
+ requester_ctx
+ .resolve_space_key_for_version_for_viewer(
+ target_space_id,
+ Some(requester_space_id),
+ None
+ )
+ .await
+ .unwrap()
+ .is_none()
+ );
let confirmed = target_ctx
.confirm_friend_request(target_space_id, request.request_id)
.await
.expect("friend request should confirm");
assert_eq!(confirmed.status, "friend");
+ let pending = target_ctx
+ .list_notifications(target_space_id, None, None)
+ .await
+ .expect("notifications should refresh");
+ assert!(
+ !pending
+ .items
+ .iter()
+ .any(|item| item.friend_request_id == Some(request.request_id))
+ );
+ let completed = pending
+ .items
+ .iter()
+ .find(|item| item.notification_id == request_notification_id)
+ .expect("accepted request should remain in the recipient's notifications");
+ assert_eq!(completed.kind, "friend_accepted");
+ assert_eq!(completed.actors[0].space_id, requester_space_id);
+ assert!(!completed.unread);
+ assert!(completed.actors[0].profile.as_ref().unwrap().is_some());
+ let accepted = requester_ctx
+ .list_notifications(requester_space_id, None, None)
+ .await
+ .expect("acceptance notification should load");
+ let notification = accepted
+ .items
+ .iter()
+ .find(|item| item.kind == "friend_accepted" && item.actors[0].space_id == target_space_id)
+ .expect("requester should be notified of acceptance");
+ assert!(notification.unread);
+ assert!(notification.actors[0].profile.as_ref().unwrap().is_some());
+ requester_ctx
+ .mark_notification_items_read(
+ requester_space_id,
+ vec![notification.notification_id.clone()],
+ )
+ .await
+ .expect("acceptance should be readable");
}
#[test]
@@ -257,19 +318,65 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {
.await
.expect("liked post should load");
assert!(liked_post.viewer_liked);
- let owner_conversations = owner_ctx
- .list_conversations(&owner_space.space_id)
- .await
- .expect("owner conversations should include post like");
- let post_like_summary = owner_conversations
- .chat_summaries
- .get(&friend_space.space_id)
- .expect("friend summary should exist after post like");
- assert_eq!(post_like_summary.latest_activity.activity_type, "post_like");
- assert_eq!(post_like_summary.latest_activity.post_id, Some(post_id));
+ let notifications = owner_ctx
+ .list_notifications(&owner_space.space_id, None, None)
+ .await
+ .expect("owner notifications should include post like");
+ assert_eq!(notifications.items.len(), 2);
+ assert_eq!(notifications.items[0].kind, "post_like");
+ assert_eq!(notifications.items[0].post_id, Some(post_id));
assert_eq!(
- post_like_summary.latest_activity.post_space_id.as_deref(),
- Some(owner_space.space_id.as_str())
+ notifications.items[0].actors[0].space_id,
+ friend_space.space_id
+ );
+
+ let poke_request = uuid::Uuid::new_v4().to_string();
+ friend_ctx
+ .send_poke(&friend_space.space_id, &owner_space.space_id, &poke_request)
+ .await
+ .unwrap();
+ friend_ctx
+ .send_poke(&friend_space.space_id, &owner_space.space_id, &poke_request)
+ .await
+ .unwrap();
+ let pokes = owner_ctx
+ .list_notifications(&owner_space.space_id, None, None)
+ .await
+ .unwrap();
+ assert_eq!(
+ pokes
+ .items
+ .iter()
+ .filter(|item| item.kind == "poke")
+ .count(),
+ 1
+ );
+ assert_eq!(pokes.items[0].kind, "poke");
+ assert_eq!(pokes.items[0].actors[0].space_id, friend_space.space_id);
+ assert!(pokes.items[0].actors[0].profile.as_ref().unwrap().is_some());
+ assert!(pokes.items[0].unread);
+ assert!(pokes.latest_post_created_at.is_some());
+ let thread = owner_ctx
+ .list_message_thread(&owner_space.space_id, &friend_space.space_id, None, None)
+ .await
+ .unwrap();
+ assert!(thread.items.is_empty());
+ assert!(
+ !owner_ctx
+ .unread_status(&owner_space.space_id)
+ .await
+ .unwrap()
+ .notifications_unread
+ );
+ space::assert_http_status(
+ outsider_ctx
+ .send_poke(
+ &outsider_space.space_id,
+ &owner_space.space_id,
+ "outsider-poke",
+ )
+ .await,
+ 403,
);
space::assert_http_status(
diff --git a/server/migrations/149_space_notifications.down.sql b/server/migrations/149_space_notifications.down.sql
new file mode 100644
index 0000000000..617f1dbfdc
--- /dev/null
+++ b/server/migrations/149_space_notifications.down.sql
@@ -0,0 +1,20 @@
+ALTER TABLE space_messages DROP CONSTRAINT chk_space_messages_kind;
+ALTER TABLE space_messages ADD CONSTRAINT chk_space_messages_kind
+ CHECK (kind IN ('regular', 'post_reply', 'post_like', 'friend_added'));
+
+INSERT INTO space_messages (
+ message_id, sender_space_id, recipient_space_id, kind, reply_post_id, created_at, updated_at
+)
+SELECT l.like_id, l.actor_space_id, p.space_id, 'post_like', l.post_id, l.created_at, l.created_at
+FROM space_post_likes l
+JOIN space_posts p ON p.post_id = l.post_id AND p.is_deleted = FALSE;
+
+INSERT INTO space_messages (
+ message_id, sender_space_id, recipient_space_id, kind, created_at, updated_at
+)
+SELECT notification_id, actor_space_id, recipient_space_id, 'friend_added', created_at, created_at
+FROM space_notifications WHERE kind = 'friend_accepted';
+
+DROP TABLE space_notifications;
+DROP TABLE space_post_likes;
+DROP TABLE space_pokes;
diff --git a/server/migrations/149_space_notifications.up.sql b/server/migrations/149_space_notifications.up.sql
new file mode 100644
index 0000000000..3d19615e7e
--- /dev/null
+++ b/server/migrations/149_space_notifications.up.sql
@@ -0,0 +1,95 @@
+LOCK TABLE space_friend_requests, space_messages IN SHARE ROW EXCLUSIVE MODE;
+
+CREATE TABLE space_post_likes (
+ like_id TEXT PRIMARY KEY,
+ post_id BIGINT NOT NULL REFERENCES space_posts (post_id) ON DELETE CASCADE,
+ actor_space_id TEXT NOT NULL REFERENCES spaces (space_id) ON DELETE CASCADE,
+ created_at BIGINT NOT NULL DEFAULT now_utc_micro_seconds(),
+ UNIQUE (post_id, actor_space_id)
+);
+
+CREATE TABLE space_pokes (
+ poke_id TEXT PRIMARY KEY,
+ sender_space_id TEXT NOT NULL REFERENCES spaces (space_id) ON DELETE CASCADE,
+ recipient_space_id TEXT NOT NULL REFERENCES spaces (space_id) ON DELETE CASCADE,
+ client_request_id TEXT NOT NULL,
+ created_at BIGINT NOT NULL DEFAULT now_utc_micro_seconds(),
+ CHECK (sender_space_id <> recipient_space_id),
+ UNIQUE (sender_space_id, recipient_space_id, client_request_id)
+);
+
+CREATE INDEX idx_space_pokes_recipient_created
+ ON space_pokes (recipient_space_id, created_at DESC);
+
+CREATE TABLE space_notifications (
+ notification_id TEXT PRIMARY KEY,
+ recipient_space_id TEXT NOT NULL REFERENCES spaces (space_id) ON DELETE CASCADE,
+ actor_space_id TEXT NOT NULL REFERENCES spaces (space_id) ON DELETE CASCADE,
+ kind TEXT NOT NULL,
+ post_like_id TEXT REFERENCES space_post_likes (like_id) ON DELETE CASCADE,
+ created_at BIGINT NOT NULL DEFAULT now_utc_micro_seconds(),
+ read_at BIGINT,
+ friend_request_id BIGINT REFERENCES space_friend_requests (request_id) ON DELETE CASCADE,
+ poke_id TEXT REFERENCES space_pokes (poke_id) ON DELETE CASCADE,
+ CHECK (recipient_space_id <> actor_space_id),
+ 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)
+ ),
+ UNIQUE (recipient_space_id, kind, post_like_id)
+);
+
+CREATE INDEX idx_space_notifications_recipient_created
+ ON space_notifications (recipient_space_id, created_at DESC, notification_id DESC);
+
+CREATE INDEX idx_space_notifications_unread
+ ON space_notifications (recipient_space_id)
+ WHERE read_at IS NULL;
+
+CREATE INDEX idx_space_notifications_post_like
+ ON space_notifications (post_like_id);
+
+CREATE UNIQUE INDEX idx_space_notifications_friend_request
+ ON space_notifications (friend_request_id) WHERE friend_request_id IS NOT NULL;
+
+CREATE UNIQUE INDEX idx_space_notifications_poke ON space_notifications (poke_id);
+
+INSERT INTO space_post_likes (like_id, post_id, actor_space_id, created_at)
+SELECT m.message_id, m.reply_post_id, m.sender_space_id, m.created_at
+FROM space_messages m
+JOIN space_posts p ON p.post_id = m.reply_post_id AND p.is_deleted = FALSE
+WHERE m.kind = 'post_like';
+
+INSERT INTO space_notifications (
+ notification_id, recipient_space_id, actor_space_id, kind, post_like_id, created_at, read_at
+)
+SELECT 'wnot_' || l.like_id, p.space_id, l.actor_space_id, 'post_like', l.like_id, l.created_at,
+ CASE WHEN marker.read_at >= l.created_at THEN marker.read_at END
+FROM space_post_likes l
+JOIN space_posts p ON p.post_id = l.post_id
+LEFT JOIN space_notification_read_markers marker
+ ON marker.viewer_space_id = p.space_id AND marker.friend_space_id = l.actor_space_id;
+
+INSERT INTO space_notifications (
+ notification_id, recipient_space_id, actor_space_id, kind, friend_request_id, created_at
+)
+SELECT 'wnot_request_' || request_id, target_space_id, requester_space_id, 'friend_request', request_id, created_at
+FROM space_friend_requests;
+
+INSERT INTO space_notifications (
+ notification_id, recipient_space_id, actor_space_id, kind, created_at, read_at
+)
+SELECT m.message_id, m.recipient_space_id, m.sender_space_id, 'friend_accepted', m.created_at,
+ CASE WHEN marker.read_at >= m.created_at THEN marker.read_at END
+FROM space_messages m
+LEFT JOIN space_notification_read_markers marker
+ ON marker.viewer_space_id = m.recipient_space_id AND marker.friend_space_id = m.sender_space_id
+WHERE m.kind = 'friend_added';
+
+DELETE FROM space_messages WHERE kind IN ('post_like', 'friend_added');
+
+ALTER TABLE space_messages DROP CONSTRAINT chk_space_messages_kind;
+ALTER TABLE space_messages ADD CONSTRAINT chk_space_messages_kind
+ CHECK (kind IN ('regular', 'post_reply'));
diff --git a/server/space/api/notifications.go b/server/space/api/notifications.go
new file mode 100644
index 0000000000..1d4fc23e74
--- /dev/null
+++ b/server/space/api/notifications.go
@@ -0,0 +1,29 @@
+package api
+
+import (
+ "github.com/ente/museum/space/models"
+ "github.com/ente/museum/space/repo"
+ "github.com/gin-gonic/gin"
+)
+
+func (h *Handlers) ListNotifications(c *gin.Context, space *repo.SpaceRecord) {
+ var req models.ListNotificationsRequest
+ if !bindQuery(c, &req) {
+ return
+ }
+ resp, err := h.Module.Notifications.List(c, space, req)
+ respondJSON(c, resp, err)
+}
+
+func (h *Handlers) GetNotificationUnread(c *gin.Context, space *repo.SpaceRecord) {
+ resp, err := h.Module.Notifications.Unread(c, space)
+ respondJSON(c, resp, err)
+}
+
+func (h *Handlers) ReadNotifications(c *gin.Context, space *repo.SpaceRecord) {
+ var req models.ReadNotificationsRequest
+ if !bindJSON(c, &req) {
+ return
+ }
+ respondStatus(c, h.Module.Notifications.MarkRead(c, space, req))
+}
diff --git a/server/space/api/notifications_test.go b/server/space/api/notifications_test.go
new file mode 100644
index 0000000000..ec40ef96da
--- /dev/null
+++ b/server/space/api/notifications_test.go
@@ -0,0 +1,102 @@
+package api
+
+import (
+ "crypto/sha256"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/ente/museum/internal/testutil"
+ timeutil "github.com/ente/museum/pkg/utils/time"
+ "github.com/ente/museum/space/controller"
+ "github.com/ente/museum/space/models"
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/require"
+)
+
+func TestNotificationsAPIIsRecipientScoped(t *testing.T) {
+ handlers, repos, ownerID := setupSpaceSessionAPITest(t, nil)
+ ctx := t.Context()
+ owner, err := testCreateSpace(ctx, repos, ownerID, "notification_owner", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ friendID := testutil.InsertUser(t, repos.Spaces.DB, testutil.UserFixture{Email: "[email protected]", CreationTime: timeutil.Microseconds()})
+ friend, err := testCreateSpace(ctx, repos, friendID, "notification_friend", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ request, _, _, err := repos.Friends.CreateFriendRequest(ctx, friendID, friend.SpaceID, owner.SpaceID, []byte("share"), 1)
+ require.NoError(t, err)
+ _, _, err = repos.Friends.ConfirmFriendRequest(ctx, owner.SpaceID, request.RequestID, []byte("share"), 1)
+ require.NoError(t, err)
+ postID, _, err := repos.Posts.CreatePost(ctx, owner.SpaceID, []byte("key"), nil, 1, nil, "")
+ require.NoError(t, err)
+ _, err = repos.Posts.SetLikeWithCreated(ctx, postID, friend.SpaceID, true)
+ require.NoError(t, err)
+ sessionToken := "notification-owner-session"
+ sessionHash := sha256.Sum256([]byte(sessionToken))
+ require.NoError(t, repos.Sessions.CreateBrowserSession(ctx, sessionHash[:], ownerID, "wrap-key", timeutil.NDaysFromNow(1)))
+ router := gin.New()
+ private := router.Group("", handlers.RequireSpaceBrowserSession())
+ Register(private, router.Group(""), handlers)
+ serve := func(method, path, body string) *httptest.ResponseRecorder {
+ req := httptest.NewRequest(method, path, strings.NewReader(body))
+ req.Header.Set(controller.SpaceBrowserSessionTokenHeader, sessionToken)
+ req.Header.Set("Content-Type", "application/json")
+ recorder := httptest.NewRecorder()
+ router.ServeHTTP(recorder, req)
+ return recorder
+ }
+ response := serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/notifications?limit=1", "")
+ require.Equal(t, http.StatusOK, response.Code, response.Body.String())
+ var page models.NotificationPage
+ require.NoError(t, json.Unmarshal(response.Body.Bytes(), &page))
+ require.Len(t, page.Items, 1)
+ require.NotNil(t, page.Items[0].PostID)
+ require.Equal(t, postID, *page.Items[0].PostID)
+ require.Equal(t, friend.SpaceID, page.Items[0].Actors[0].SpaceID)
+ require.Equal(t, int64(1), page.Items[0].ActorCount)
+ require.True(t, page.Items[0].Unread)
+ require.NotEmpty(t, page.NextCursor)
+ olderResponse := serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/notifications?cursor="+page.NextCursor, "")
+ require.Equal(t, http.StatusOK, olderResponse.Code, olderResponse.Body.String())
+ var olderPage models.NotificationPage
+ require.NoError(t, json.Unmarshal(olderResponse.Body.Bytes(), &olderPage))
+ require.Len(t, olderPage.Items, 1)
+ require.Equal(t, "friend_accepted", olderPage.Items[0].Kind)
+ require.Equal(t, friend.SpaceID, olderPage.Items[0].Actors[0].SpaceID)
+ require.False(t, olderPage.Items[0].Unread)
+ require.Nil(t, olderPage.Items[0].FriendRequestID)
+ response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/notifications/unread", "")
+ require.JSONEq(t, `{"unread":true}`, response.Body.String())
+ response = serve(http.MethodGet, "/spaces/"+friend.SpaceID+"/notifications", "")
+ require.Equal(t, http.StatusForbidden, response.Code)
+ response = serve(http.MethodPost, "/spaces/"+friend.SpaceID+"/notifications/read", `{"notificationIds":["`+page.Items[0].NotificationID+`"]}`)
+ require.Equal(t, http.StatusForbidden, response.Code)
+ response = serve(http.MethodPost, "/spaces/"+owner.SpaceID+"/notifications/read", `{"notificationIds":[]}`)
+ require.Equal(t, http.StatusBadRequest, response.Code)
+ response = serve(http.MethodPost, "/spaces/"+owner.SpaceID+"/notifications/read", `{"notificationIds":["`+page.Items[0].NotificationID+`"]}`)
+ require.Equal(t, http.StatusOK, response.Code)
+ response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/notifications/unread", "")
+ require.JSONEq(t, `{"unread":false}`, response.Body.String())
+ require.NoError(t, repos.Friends.DeleteFriendship(ctx, owner.SpaceID, friend.SpaceID))
+ _, err = repos.Spaces.DB.ExecContext(ctx, `INSERT INTO space_profile_assets (space_id, asset_type, object_id, bucket_id, key_version) VALUES ($1, 'avatar', 'private-avatar', 'test-bucket', 1)`, friend.SpaceID)
+ require.NoError(t, err)
+ request, _, _, err = repos.Friends.CreateFriendRequest(ctx, friendID, friend.SpaceID, owner.SpaceID, []byte("share"), 1)
+ require.NoError(t, err)
+ response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/notifications", "")
+ require.Equal(t, http.StatusOK, response.Code, response.Body.String())
+ page = models.NotificationPage{}
+ require.NoError(t, json.Unmarshal(response.Body.Bytes(), &page))
+ require.Len(t, page.Items, 1)
+ require.Equal(t, "friend_request", page.Items[0].Kind)
+ require.NotNil(t, page.Items[0].FriendRequestID)
+ require.Equal(t, request.RequestID, *page.Items[0].FriendRequestID)
+ require.Nil(t, page.Items[0].PostID)
+ require.Empty(t, page.Items[0].Actors[0].EncryptedProfile)
+ require.Nil(t, page.Items[0].Actors[0].Avatar)
+ response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/unread", "")
+ require.JSONEq(t, `{"notificationsUnread":false}`, response.Body.String())
+ response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/conversations", "")
+ require.Equal(t, http.StatusOK, response.Code, response.Body.String())
+ require.NotContains(t, response.Body.String(), "pendingRequests")
+}
diff --git a/server/space/api/pokes.go b/server/space/api/pokes.go
new file mode 100644
index 0000000000..e657032b82
--- /dev/null
+++ b/server/space/api/pokes.go
@@ -0,0 +1,19 @@
+package api
+
+import (
+ "github.com/ente/museum/space/models"
+ "github.com/ente/museum/space/repo"
+ "github.com/gin-gonic/gin"
+)
+
+func (h *Handlers) CreatePoke(c *gin.Context, space *repo.SpaceRecord) {
+ var req models.CreatePokeRequest
+ if !bindJSON(c, &req) {
+ return
+ }
+ friendSpaceID, ok := stringParam(c, "friendSpaceID")
+ if !ok {
+ return
+ }
+ respondStatus(c, h.Module.Pokes.Create(c, space, friendSpaceID, req))
+}
diff --git a/server/space/api/register.go b/server/space/api/register.go
index 0e889440b5..c8fedb7c70 100644
--- a/server/space/api/register.go
+++ b/server/space/api/register.go
@@ -15,6 +15,9 @@ func Register(privateAPI, publicAPI gin.IRouter, handlers *Handlers) {
spaceAPI.PATCH("/slug", selected(handlers.UpdateSpaceSlug))
spaceAPI.POST("/uploads/presign", selected(handlers.PresignUpload))
spaceAPI.GET("/unread", selected(handlers.GetUnreadStatus))
+ spaceAPI.GET("/notifications", selected(handlers.ListNotifications))
+ spaceAPI.GET("/notifications/unread", selected(handlers.GetNotificationUnread))
+ spaceAPI.POST("/notifications/read", selected(handlers.ReadNotifications))
spaceAPI.POST("/posts", selected(handlers.CreatePost))
spaceAPI.GET("/feed", selected(handlers.ListFeed))
spaceAPI.POST("/posts/:postID/caption", selected(handlers.UpdatePostCaption))
@@ -23,6 +26,7 @@ func Register(privateAPI, publicAPI gin.IRouter, handlers *Handlers) {
spaceAPI.DELETE("/posts/:postID/like", selected(handlers.UnlikePost))
spaceAPI.POST("/posts/:postID/reply", selected(handlers.ReplyToPost))
spaceAPI.DELETE("/posts/:postID", selected(handlers.DeletePost))
+ spaceAPI.POST("/friends/:friendSpaceID/pokes", selected(handlers.CreatePoke))
spaceAPI.GET("/conversations", selected(handlers.ListConversations))
spaceAPI.POST("/friends/:friendSpaceID/read", selected(handlers.MarkNotificationsRead))
spaceAPI.GET("/friends/:friendSpaceID/messages", selected(handlers.ListMessageThread))
diff --git a/server/space/controller/messages.go b/server/space/controller/messages.go
index 91d696e75f..47e4773683 100644
--- a/server/space/controller/messages.go
+++ b/server/space/controller/messages.go
@@ -13,10 +13,8 @@ import (
)
const (
- spaceMessageKindRegular = "regular"
- spaceMessageKindPostReply = "post_reply"
- spaceMessageKindPostLike = "post_like"
- spaceMessageKindFriendAdded = "friend_added"
+ spaceMessageKindRegular = "regular"
+ spaceMessageKindPostReply = "post_reply"
spaceMessageNotificationKindPoke = "poke"
@@ -144,10 +142,6 @@ func (c *MessagesController) ListConversations(ctx context.Context, viewerSpace
if err != nil {
return nil, err
}
- pendingRequests, err := c.FriendsRepo.ListFriendRequestsForSpace(ctx, viewerSpace.SpaceID)
- if err != nil {
- return nil, err
- }
friendResponses := make([]models.SpaceFriendResponse, 0, len(friends))
friendSpaceIDs := make([]string, 0, len(friends))
for _, friend := range friends {
@@ -177,18 +171,9 @@ func (c *MessagesController) ListConversations(ctx context.Context, viewerSpace
UnreadActivities: unreadActivities,
}
}
- requestResponses := make([]models.SpaceFriendRequestResponse, 0, len(pendingRequests))
- for _, request := range pendingRequests {
- requestResponses = append(requestResponses, models.SpaceFriendRequestResponse{
- RequestID: request.RequestID,
- Requester: toActorResponse(request.Requester, true),
- CreatedAt: formatMicros(request.CreatedAt),
- })
- }
response := &models.ConversationsResponse{
- Friends: friendResponses,
- PendingRequests: requestResponses,
- ChatSummaries: chatSummaries,
+ Friends: friendResponses,
+ ChatSummaries: chatSummaries,
}
if latestPostCreatedAt > 0 {
response.LatestPostCreatedAt = formatMicros(latestPostCreatedAt)
@@ -492,5 +477,5 @@ func toMessageConversationActivityResponse(activity repo.SpaceMessageConversatio
}
func toUnreadMessageConversationActivityResponse(activity repo.SpaceMessageConversationActivityRecord) models.MessageConversationActivityResponse {
- return toMessageConversationActivityMetadataResponse(activity)
+ return toMessageConversationActivityResponse(activity)
}
diff --git a/server/space/controller/messages_test.go b/server/space/controller/messages_test.go
index 8090085c45..64040f9336 100644
--- a/server/space/controller/messages_test.go
+++ b/server/space/controller/messages_test.go
@@ -104,7 +104,7 @@ func TestMessageLikeAndDeleteAccess(t *testing.T) {
require.True(t, errors.Is(err, ente.ErrPermissionDenied))
thread, _, err := repos.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
- require.Len(t, thread, 2)
+ require.Len(t, thread, 1)
require.Error(t, controller.Delete(ctx, aliceSpace, message.MessageID))
err = controller.Delete(ctx, bobSpace, message.MessageID)
@@ -120,7 +120,7 @@ func TestListThreadHidesDeletedTargetOwner(t *testing.T) {
page, err := controller.ListThread(ctx, aliceSpace, bobSpace.SpaceID, models.ListMessageThreadRequest{})
require.NoError(t, err)
- require.Len(t, page.Items, 2)
+ require.Len(t, page.Items, 1)
_, err = repos.Spaces.DB.Exec(`UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, bobID)
require.NoError(t, err)
diff --git a/server/space/controller/module.go b/server/space/controller/module.go
index c876b73d8d..4f875f534a 100644
--- a/server/space/controller/module.go
+++ b/server/space/controller/module.go
@@ -7,18 +7,20 @@ import (
)
type Module struct {
- Spaces *SpacesController
- Posts *PostsController
- Friends *FriendsController
- Messages *MessagesController
- Assets *AssetsController
- Read *ReadMarkersController
- Sessions *SessionsController
- WebPush *WebPushController
- Cleanup *CleanupController
- Links *LinksController
- UserTokens UserTokenTerminator
- auth authDeps
+ Spaces *SpacesController
+ Posts *PostsController
+ Friends *FriendsController
+ Messages *MessagesController
+ Assets *AssetsController
+ Read *ReadMarkersController
+ Notifications *NotificationsController
+ Pokes *PokesController
+ Sessions *SessionsController
+ WebPush *WebPushController
+ Cleanup *CleanupController
+ Links *LinksController
+ UserTokens UserTokenTerminator
+ auth authDeps
}
type UserTokenTerminator interface {
@@ -42,17 +44,19 @@ 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{
- Spaces: spaces,
- Posts: posts,
- Friends: &FriendsController{FriendsRepo: repos.Friends, SpacesRepo: repos.Spaces, ActivityNotifier: activityNotifier},
- Messages: &MessagesController{MessagesRepo: repos.Messages, PostsRepo: repos.Posts, SpacesRepo: repos.Spaces, FriendsRepo: repos.Friends, ReadMarkersRepo: repos.Read, ActivityNotifier: activityNotifier, auth: authDeps},
- Assets: assets,
- Read: &ReadMarkersController{ReadMarkersRepo: repos.Read},
- Sessions: &SessionsController{SessionsRepo: repos.Sessions},
- WebPush: &WebPushController{webPushRepo: repos.WebPush, links: links, config: webPushConfig},
- Cleanup: &CleanupController{AssetsRepo: repos.Assets},
- Links: links,
- auth: authDeps,
+ Spaces: spaces,
+ Posts: posts,
+ Friends: &FriendsController{FriendsRepo: repos.Friends, SpacesRepo: repos.Spaces, ActivityNotifier: activityNotifier},
+ Messages: &MessagesController{MessagesRepo: repos.Messages, PostsRepo: repos.Posts, SpacesRepo: repos.Spaces, FriendsRepo: repos.Friends, ReadMarkersRepo: repos.Read, ActivityNotifier: activityNotifier, auth: authDeps},
+ Assets: assets,
+ Read: &ReadMarkersController{ReadMarkersRepo: repos.Read},
+ Notifications: &NotificationsController{NotificationsRepo: repos.Notifications, PostsRepo: repos.Posts},
+ Pokes: &PokesController{PokesRepo: repos.Pokes, SpacesRepo: repos.Spaces, ActivityNotifier: activityNotifier, auth: authDeps},
+ Sessions: &SessionsController{SessionsRepo: repos.Sessions},
+ WebPush: &WebPushController{webPushRepo: repos.WebPush, links: links, config: webPushConfig},
+ Cleanup: &CleanupController{AssetsRepo: repos.Assets},
+ Links: links,
+ auth: authDeps,
}
}
diff --git a/server/space/controller/notification_feed.go b/server/space/controller/notification_feed.go
new file mode 100644
index 0000000000..08347371bd
--- /dev/null
+++ b/server/space/controller/notification_feed.go
@@ -0,0 +1,67 @@
+package controller
+
+import (
+ "context"
+
+ "github.com/ente/museum/space/models"
+ "github.com/ente/museum/space/repo"
+)
+
+type NotificationsController struct {
+ NotificationsRepo *repo.NotificationsRepository
+ PostsRepo *repo.PostsRepository
+}
+
+func (c *NotificationsController) List(ctx context.Context, space *repo.SpaceRecord, req models.ListNotificationsRequest) (*models.NotificationPage, error) {
+ records, cursor, err := c.NotificationsRepo.List(ctx, space.SpaceID, req.Cursor, req.Limit)
+ if err != nil {
+ return nil, err
+ }
+ items := make([]models.NotificationResponse, 0, len(records))
+ for _, record := range records {
+ item := models.NotificationResponse{
+ NotificationID: record.NotificationID,
+ Kind: record.Kind,
+ Actors: make([]models.SpaceActorResponse, 0, len(record.Actors)),
+ ActorCount: record.ActorCount,
+ CreatedAt: formatMicros(record.CreatedAt),
+ Unread: record.Unread,
+ }
+ if record.PostID.Valid {
+ item.PostID = &record.PostID.Int64
+ }
+ if record.FriendRequestID.Valid {
+ item.FriendRequestID = &record.FriendRequestID.Int64
+ }
+ for _, actor := range record.Actors {
+ response := toActorResponse(actor, true)
+ if record.Kind == "friend_request" {
+ response.EncryptedProfile = ""
+ response.Avatar = nil
+ }
+ item.Actors = append(item.Actors, response)
+ }
+ items = append(items, item)
+ }
+ latestPostCreatedAt, err := c.PostsRepo.LatestPostCreatedAt(ctx, space.SpaceID)
+ if err != nil {
+ return nil, err
+ }
+ page := &models.NotificationPage{Items: items, NextCursor: cursor}
+ if latestPostCreatedAt > 0 {
+ page.LatestPostCreatedAt = formatMicros(latestPostCreatedAt)
+ }
+ return page, nil
+}
+
+func (c *NotificationsController) Unread(ctx context.Context, space *repo.SpaceRecord) (*models.NotificationUnreadResponse, error) {
+ unread, err := c.NotificationsRepo.HasUnread(ctx, space.SpaceID)
+ if err != nil {
+ return nil, err
+ }
+ return &models.NotificationUnreadResponse{Unread: unread}, nil
+}
+
+func (c *NotificationsController) MarkRead(ctx context.Context, space *repo.SpaceRecord, req models.ReadNotificationsRequest) error {
+ return c.NotificationsRepo.MarkRead(ctx, space.SpaceID, req.NotificationIDs)
+}
diff --git a/server/space/controller/notifications.go b/server/space/controller/notifications.go
index 232931c179..30b4c0cff0 100644
--- a/server/space/controller/notifications.go
+++ b/server/space/controller/notifications.go
@@ -127,7 +127,7 @@ func (n *SpaceWebPushSender) OnSpacePostCreated(actor SpaceActivityActor, postID
}
func (n *SpaceWebPushSender) OnSpacePostLiked(actor SpaceActivityActor, recipientUserID int64) {
- n.sendAccountActivity(actor, "liked your post", "", spaceActivityPostLiked, conversationURL(actor.SpaceID), recipientUserID)
+ n.sendAccountActivity(actor, "liked your post", "", spaceActivityPostLiked, "/app/notifications", recipientUserID)
}
func (n *SpaceWebPushSender) OnSpacePostReplied(actor SpaceActivityActor, recipientUserID int64) {
@@ -149,8 +149,8 @@ func (n *SpaceWebPushSender) OnSpaceMessageLiked(actor SpaceActivityActor, recip
func (n *SpaceWebPushSender) OnSpaceFriendAdded(actor SpaceActivityActor, recipientUserID int64) {
n.sendAccountActivity(
actor,
- "is now your friend",
- "Say hi to "+spaceActivityActorLabel(actor.Slug),
+ "accepted your friend request",
+ "Say hi",
spaceActivityFriendAdded,
conversationURL(actor.SpaceID),
recipientUserID,
@@ -158,7 +158,7 @@ func (n *SpaceWebPushSender) OnSpaceFriendAdded(actor SpaceActivityActor, recipi
}
func (n *SpaceWebPushSender) OnSpaceFriendRequested(actor SpaceActivityActor, recipientUserID int64) {
- n.sendAccountActivity(actor, "sent you a friend request", "Review request", spaceActivityFriendRequested, "/app/messages", recipientUserID)
+ n.sendAccountActivity(actor, "sent you a friend request", "Review request", spaceActivityFriendRequested, "/app/notifications", recipientUserID)
}
func (n *SpaceWebPushSender) sendAccountActivity(
diff --git a/server/space/controller/notifications_test.go b/server/space/controller/notifications_test.go
index cee86849e6..2a0c088800 100644
--- a/server/space/controller/notifications_test.go
+++ b/server/space/controller/notifications_test.go
@@ -417,6 +417,28 @@ func TestPublicPostPushCarriesOnlyOpaqueLocalRouteTarget(t *testing.T) {
}, payload)
}
+func TestFriendPushNotificationDestinations(t *testing.T) {
+ _, repos, ctx := setupPostsControllerTest(t)
+ recipientID := insertSpaceControllerUser(t, repos, "[email protected]", "recipient-public")
+ sessionHash := []byte("friend-push-session")
+ require.NoError(t, repos.Sessions.CreateBrowserSession(ctx, sessionHash, recipientID, "wrap-key", timeutil.NDaysFromNow(1)))
+ _, err := repos.WebPush.UpsertAccountSubscription(ctx, sessionHash, "https://fcm.googleapis.com/wp/friend", "p256dh", "auth")
+ require.NoError(t, err)
+ originalSend := sendSpaceWebPush
+ t.Cleanup(func() { sendSpaceWebPush = originalSend })
+ var payload spaceWebPushPayload
+ sendSpaceWebPush = func(_ context.Context, message []byte, _ *webpush.Subscription, _ *webpush.Options) (*http.Response, error) {
+ require.NoError(t, json.Unmarshal(message, &payload))
+ 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"}
+ 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)
+}
+
func TestSpaceWebPushSendRateAppliesOncePerActivity(t *testing.T) {
config := newSpaceWebPushTestConfig(t)
diff --git a/server/space/controller/pokes.go b/server/space/controller/pokes.go
new file mode 100644
index 0000000000..bf0a2a4c84
--- /dev/null
+++ b/server/space/controller/pokes.go
@@ -0,0 +1,48 @@
+package controller
+
+import (
+ "context"
+ "database/sql"
+ "errors"
+ "strings"
+
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/space/models"
+ "github.com/ente/museum/space/repo"
+ "github.com/ente/stacktrace"
+)
+
+type PokesController struct {
+ PokesRepo *repo.PokesRepository
+ SpacesRepo *repo.SpacesRepository
+ ActivityNotifier SpaceActivityNotifier
+ auth authDeps
+}
+
+func (c *PokesController) Create(ctx context.Context, sender *repo.SpaceRecord, targetSpaceID string, req models.CreatePokeRequest) error {
+ requestID := strings.TrimSpace(req.ClientRequestID)
+ if requestID == "" || len(requestID) > 64 {
+ return ente.NewBadRequestWithMessage("invalid poke request ID")
+ }
+ recipient, err := c.SpacesRepo.GetSpaceByID(ctx, strings.TrimSpace(targetSpaceID))
+ if err != nil {
+ return err
+ }
+ if recipient.OwnerID == sender.OwnerID {
+ return ente.NewBadRequestWithMessage("cannot poke your own space")
+ }
+ if err := c.auth.requireActiveSpaceOwner(ctx, recipient); err != nil {
+ return err
+ }
+ created, err := c.PokesRepo.Create(ctx, sender.SpaceID, recipient.SpaceID, requestID)
+ if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
+ return ente.ErrPermissionDenied
+ }
+ if err != nil {
+ return err
+ }
+ if created {
+ go c.ActivityNotifier.OnSpacePokeSent(spaceActivityActor(sender), recipient.OwnerID)
+ }
+ return nil
+}
diff --git a/server/space/controller/pokes_test.go b/server/space/controller/pokes_test.go
new file mode 100644
index 0000000000..943336463e
--- /dev/null
+++ b/server/space/controller/pokes_test.go
@@ -0,0 +1,30 @@
+package controller
+
+import (
+ "testing"
+
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/space/models"
+ "github.com/stretchr/testify/require"
+)
+
+func TestPokesRequireFriendshipAndNotifyOnlyOnce(t *testing.T) {
+ _, repos, ctx := setupMessagesControllerTest(t)
+ notifier := newRecordingSpaceActivityNotifier()
+ controller := NewModule(repos, nil, notifier, nil).Pokes
+ aliceID, alice := createMessageControllerUserAndSpace(t, repos, "alice-pokes", "alice-pokes-public")
+ bobID, bob := createMessageControllerUserAndSpace(t, repos, "bob-pokes", "bob-pokes-public")
+ require.Error(t, controller.Create(ctx, alice, alice.SpaceID, models.CreatePokeRequest{ClientRequestID: "self"}))
+ require.ErrorIs(t, controller.Create(ctx, alice, bob.SpaceID, models.CreatePokeRequest{ClientRequestID: "stranger"}), ente.ErrPermissionDenied)
+ require.NoError(t, testAddFriend(ctx, repos, bobID, bob.SpaceID, alice.SpaceID, "alice-share-key", 1, "bob-share-key", 1))
+ require.Error(t, controller.Create(ctx, alice, bob.SpaceID, models.CreatePokeRequest{}))
+ requireNoSpaceActivity(t, notifier)
+ request := models.CreatePokeRequest{ClientRequestID: "poke-request-1"}
+ require.NoError(t, controller.Create(ctx, alice, bob.SpaceID, request))
+ event := requireSpaceActivity(t, notifier)
+ require.Equal(t, spaceActivityPokeSent, event.event)
+ require.Equal(t, aliceID, event.actorUserID)
+ require.Equal(t, []int64{bobID}, event.recipientIDs)
+ require.NoError(t, controller.Create(ctx, alice, bob.SpaceID, request))
+ requireNoSpaceActivity(t, notifier)
+}
diff --git a/server/space/models/models.go b/server/space/models/models.go
index b33da65dd1..053a802b1e 100644
--- a/server/space/models/models.go
+++ b/server/space/models/models.go
@@ -310,6 +310,10 @@ type UpdatePostCaptionRequest struct {
CaptionCipher *string `json:"captionCipher,omitempty"`
}
+type CreatePokeRequest struct {
+ ClientRequestID string `json:"clientRequestId" binding:"required,max=64"`
+}
+
type CreateMessageRequest struct {
MessageID string `json:"messageId,omitempty"`
MessageCipher string `json:"messageCipher" binding:"required"`
@@ -375,7 +379,6 @@ type ConversationChatSummaryResponse struct {
type ConversationsResponse struct {
Friends []SpaceFriendResponse `json:"friends"`
- PendingRequests []SpaceFriendRequestResponse `json:"pendingRequests"`
ChatSummaries map[string]ConversationChatSummaryResponse `json:"chatSummaries"`
LatestPostCreatedAt string `json:"latestPostCreatedAt,omitempty"`
}
@@ -409,3 +412,33 @@ type PostPage struct {
Items []PostResponse `json:"items"`
NextCursor string `json:"nextCursor,omitempty"`
}
+
+type ListNotificationsRequest struct {
+ Cursor string `form:"cursor"`
+ Limit int `form:"limit" binding:"omitempty,min=1,max=100"`
+}
+
+type ReadNotificationsRequest struct {
+ NotificationIDs []string `json:"notificationIds" binding:"required,min=1,max=100,dive,required,max=100"`
+}
+
+type NotificationResponse struct {
+ NotificationID string `json:"notificationId"`
+ Kind string `json:"kind"`
+ Actors []SpaceActorResponse `json:"actors"`
+ ActorCount int64 `json:"actorCount"`
+ PostID *int64 `json:"postId,omitempty"`
+ CreatedAt string `json:"createdAt"`
+ Unread bool `json:"unread"`
+ FriendRequestID *int64 `json:"friendRequestId,omitempty"`
+}
+
+type NotificationPage struct {
+ LatestPostCreatedAt string `json:"latestPostCreatedAt,omitempty"`
+ Items []NotificationResponse `json:"items"`
+ NextCursor string `json:"nextCursor,omitempty"`
+}
+
+type NotificationUnreadResponse struct {
+ Unread bool `json:"unread"`
+}
diff --git a/server/space/repo/friend_notifications_test.go b/server/space/repo/friend_notifications_test.go
new file mode 100644
index 0000000000..718b3cb6e0
--- /dev/null
+++ b/server/space/repo/friend_notifications_test.go
@@ -0,0 +1,260 @@
+package repo
+
+import (
+ "database/sql"
+ "os"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestFriendNotificationsFollowRequestLifecycle(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ require.NoError(t, module.Friends.DeleteFriendship(ctx, alice.SpaceID, bob.SpaceID))
+ for _, canceler := range []string{bob.SpaceID, alice.SpaceID} {
+ request, created, _, err := module.Friends.CreateFriendRequest(ctx, bob.OwnerID, bob.SpaceID, alice.SpaceID, []byte("share"), 1)
+ require.NoError(t, err)
+ require.True(t, created)
+ items, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.Equal(t, "friend_request", items[0].Kind)
+ require.Equal(t, request.RequestID, items[0].FriendRequestID.Int64)
+ require.False(t, items[0].PostID.Valid)
+ require.True(t, items[0].Unread)
+ messageUnread, err := module.Read.HasUnreadNotifications(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, messageUnread)
+ require.NoError(t, module.Notifications.MarkRead(ctx, bob.SpaceID, []string{items[0].NotificationID}))
+ unread, err := module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.True(t, unread)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{items[0].NotificationID}))
+ duplicate, created, _, err := module.Friends.CreateFriendRequest(ctx, bob.OwnerID, bob.SpaceID, alice.SpaceID, []byte("updated-share"), 1)
+ require.NoError(t, err)
+ require.False(t, created)
+ require.Equal(t, request.RequestID, duplicate.RequestID)
+ items, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.False(t, items[0].Unread)
+ require.NoError(t, module.Friends.DeleteFriendRequest(ctx, canceler, request.RequestID))
+ items, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Empty(t, items)
+ }
+ request, _, _, err := module.Friends.CreateFriendRequest(ctx, bob.OwnerID, bob.SpaceID, alice.SpaceID, []byte("share"), 1)
+ require.NoError(t, err)
+ pending, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, pending, 1)
+ _, _, err = module.Friends.ConfirmFriendRequest(ctx, alice.SpaceID, request.RequestID, []byte("share"), 1)
+ require.NoError(t, err)
+ items, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.Equal(t, pending[0].NotificationID, items[0].NotificationID)
+ require.Equal(t, "friend_accepted", items[0].Kind)
+ require.Equal(t, bob.SpaceID, items[0].Actors[0].SpaceID)
+ require.GreaterOrEqual(t, items[0].CreatedAt, pending[0].CreatedAt)
+ require.False(t, items[0].FriendRequestID.Valid)
+ require.False(t, items[0].Unread)
+ accepterUnread, err := module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, accepterUnread)
+ items, _, err = module.Notifications.List(ctx, bob.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.Equal(t, "friend_accepted", items[0].Kind)
+ require.Equal(t, alice.SpaceID, items[0].Actors[0].SpaceID)
+ require.False(t, items[0].FriendRequestID.Valid)
+ require.True(t, items[0].Unread)
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_messages`))
+ postID, err := testCreatePost(ctx, module, bob.OwnerID, bob.SpaceID, "key", nil, 1, nil)
+ require.NoError(t, err)
+ require.NoError(t, testSetPostLike(ctx, module, postID, alice.SpaceID, true))
+ first, cursor, err := module.Notifications.List(ctx, bob.SpaceID, "", 1)
+ require.NoError(t, err)
+ require.Len(t, first, 1)
+ require.Equal(t, "post_like", first[0].Kind)
+ require.NotEmpty(t, cursor)
+ second, cursor, err := module.Notifications.List(ctx, bob.SpaceID, cursor, 1)
+ require.NoError(t, err)
+ require.Len(t, second, 1)
+ require.Equal(t, items[0].NotificationID, second[0].NotificationID)
+ require.Empty(t, cursor)
+ require.NoError(t, module.Notifications.MarkRead(ctx, bob.SpaceID, []string{items[0].NotificationID}))
+ unread, err := module.Notifications.HasUnread(ctx, bob.SpaceID)
+ require.NoError(t, err)
+ require.True(t, unread)
+ require.NoError(t, module.Friends.DeleteFriendship(ctx, alice.SpaceID, bob.SpaceID))
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications WHERE kind = 'friend_accepted'`))
+}
+
+func TestReciprocalFriendRequestsKeepFriendshipNotifications(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ require.NoError(t, module.Friends.DeleteFriendship(ctx, alice.SpaceID, bob.SpaceID))
+ _, _, _, err := module.Friends.CreateFriendRequest(ctx, bob.OwnerID, bob.SpaceID, alice.SpaceID, []byte("share"), 1)
+ require.NoError(t, err)
+ pending, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, pending, 1)
+ _, created, becameFriends, err := module.Friends.CreateFriendRequest(ctx, alice.OwnerID, alice.SpaceID, bob.SpaceID, []byte("share"), 1)
+ require.NoError(t, err)
+ require.False(t, created)
+ require.True(t, becameFriends)
+ items, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.Equal(t, pending[0].NotificationID, items[0].NotificationID)
+ require.Equal(t, "friend_accepted", items[0].Kind)
+ require.Equal(t, bob.SpaceID, items[0].Actors[0].SpaceID)
+ require.False(t, items[0].FriendRequestID.Valid)
+ require.False(t, items[0].Unread)
+ items, _, err = module.Notifications.List(ctx, bob.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.Equal(t, "friend_accepted", items[0].Kind)
+ require.Equal(t, alice.SpaceID, items[0].Actors[0].SpaceID)
+ require.True(t, items[0].Unread)
+ _, _, _, err = module.Friends.CreateFriendRequest(ctx, alice.OwnerID, alice.SpaceID, bob.SpaceID, []byte("share"), 1)
+ require.ErrorIs(t, err, ErrAlreadyFriends)
+ require.Equal(t, int64(2), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications`))
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests`))
+}
+
+func TestFriendAcceptanceNotificationsGroupByActor(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ charlieID := insertSpaceUser(t, module, "[email protected]", "public")
+ charlie, err := testCreateSpace(ctx, module, charlieID, "charlie_notifications", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ require.NoError(t, testAddFriend(ctx, module, charlieID, charlie.SpaceID, alice.SpaceID, "share", 1, "share", 1))
+ _, err = module.Notifications.DB.ExecContext(ctx, `
+ INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, created_at, read_at)
+ VALUES ('bob-old', $1, $2, 'friend_accepted', 1000, NULL),
+ ('bob-a-latest', $1, $2, 'friend_accepted', 3000, NULL),
+ ('bob-z-latest', $1, $2, 'friend_accepted', 3000, 4000),
+ ('charlie-old', $1, $3, 'friend_accepted', 500, NULL),
+ ('charlie-latest', $1, $3, 'friend_accepted', 2000, NULL),
+ ('alice-other-recipient', $2, $1, 'friend_accepted', 3500, NULL)
+ `, alice.SpaceID, bob.SpaceID, charlie.SpaceID)
+ require.NoError(t, err)
+ postID, err := testCreatePost(ctx, module, alice.OwnerID, alice.SpaceID, "key", nil, 1, nil)
+ require.NoError(t, err)
+ require.NoError(t, testSetPostLike(ctx, module, postID, bob.SpaceID, true))
+ var likeID string
+ require.NoError(t, module.Notifications.DB.QueryRowContext(ctx, `
+ UPDATE space_notifications SET created_at = 1500 WHERE kind = 'post_like' RETURNING notification_id
+ `).Scan(&likeID))
+
+ cursor := ""
+ for i, id := range []string{"bob-z-latest", "charlie-latest", likeID} {
+ items, next, err := module.Notifications.List(ctx, alice.SpaceID, cursor, 1)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.Equal(t, id, items[0].NotificationID)
+ require.Equal(t, int64(1), items[0].ActorCount)
+ require.Len(t, items[0].Actors, 1)
+ require.True(t, items[0].Unread)
+ if i < 2 {
+ require.Equal(t, "friend_accepted", items[0].Kind)
+ require.Equal(t, []string{bob.SpaceID, charlie.SpaceID}[i], items[0].Actors[0].SpaceID)
+ require.Equal(t, []int64{3000, 2000}[i], items[0].CreatedAt)
+ require.NotEmpty(t, next)
+ } else {
+ require.Equal(t, "post_like", items[0].Kind)
+ require.Empty(t, next)
+ }
+ cursor = next
+ }
+
+ require.NoError(t, module.Notifications.MarkRead(ctx, bob.SpaceID, []string{"bob-z-latest"}))
+ require.Equal(t, int64(2), countSpaceRows(t, module, `
+ SELECT COUNT(*) FROM space_notifications WHERE recipient_space_id = $1 AND actor_space_id = $2 AND kind = 'friend_accepted' AND read_at IS NULL
+ `, alice.SpaceID, bob.SpaceID))
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{"bob-z-latest"}))
+ items, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 3)
+ require.False(t, items[0].Unread)
+ require.True(t, items[1].Unread)
+ require.True(t, items[2].Unread)
+ require.Equal(t, int64(0), countSpaceRows(t, module, `
+ SELECT COUNT(*) FROM space_notifications WHERE recipient_space_id = $1 AND actor_space_id = $2 AND kind = 'friend_accepted' AND read_at IS NULL
+ `, alice.SpaceID, bob.SpaceID))
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{"charlie-latest", likeID}))
+ unread, err := module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, unread)
+ unread, err = module.Notifications.HasUnread(ctx, bob.SpaceID)
+ require.NoError(t, err)
+ require.True(t, unread)
+
+ _, err = module.Notifications.DB.ExecContext(ctx, `
+ INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, created_at)
+ VALUES ('bob-new', $1, $2, 'friend_accepted', 5000)
+ `, alice.SpaceID, bob.SpaceID)
+ require.NoError(t, err)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{"bob-z-latest"}))
+ items, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 3)
+ require.Equal(t, "bob-new", items[0].NotificationID)
+ require.True(t, items[0].Unread)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{"bob-new"}))
+ unread, err = module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, unread)
+}
+
+func TestFriendNotificationsMigrationPreservesRequestsAndAcceptanceReadState(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ postID, err := testCreatePost(ctx, module, alice.OwnerID, alice.SpaceID, "key", nil, 1, nil)
+ require.NoError(t, err)
+ require.NoError(t, testSetPostLike(ctx, module, postID, bob.SpaceID, true))
+ up, err := os.ReadFile("migrations/149_space_notifications.up.sql")
+ require.NoError(t, err)
+ down, err := os.ReadFile("migrations/149_space_notifications.down.sql")
+ require.NoError(t, err)
+ tx, err := module.Notifications.DB.BeginTx(ctx, nil)
+ require.NoError(t, err)
+ defer tx.Rollback()
+ _, err = tx.ExecContext(ctx, string(down))
+ require.NoError(t, err)
+ var requestID int64
+ require.NoError(t, tx.QueryRowContext(ctx, `INSERT INTO space_friend_requests (requester_space_id, target_space_id, requester_friend_sealed_space_key, created_at) VALUES ($1, $2, $3, 1000) RETURNING request_id`, bob.SpaceID, alice.SpaceID, []byte("share")).Scan(&requestID))
+ _, err = tx.ExecContext(ctx, `INSERT INTO space_messages (message_id, sender_space_id, recipient_space_id, kind, created_at) VALUES ('read-acceptance', $1, $2, 'friend_added', 1000), ('unread-acceptance', $1, $2, 'friend_added', 3000)`, alice.SpaceID, bob.SpaceID)
+ require.NoError(t, err)
+ _, err = tx.ExecContext(ctx, `UPDATE space_notification_read_markers SET read_at = 2000 WHERE viewer_space_id = $1 AND friend_space_id = $2`, bob.SpaceID, alice.SpaceID)
+ require.NoError(t, err)
+ _, err = tx.ExecContext(ctx, string(up))
+ require.NoError(t, err)
+ var readAt sql.NullInt64
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT read_at FROM space_notifications WHERE notification_id = 'read-acceptance'`).Scan(&readAt))
+ require.Equal(t, sql.NullInt64{Int64: 2000, Valid: true}, readAt)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT read_at FROM space_notifications WHERE notification_id = 'unread-acceptance'`).Scan(&readAt))
+ require.False(t, readAt.Valid)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT read_at FROM space_notifications WHERE friend_request_id = $1`, requestID).Scan(&readAt))
+ require.False(t, readAt.Valid)
+ var count int
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_notifications WHERE kind = 'post_like'`).Scan(&count))
+ require.Equal(t, 1, count)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_messages`).Scan(&count))
+ require.Zero(t, count)
+ _, err = tx.ExecContext(ctx, `DELETE FROM space_friend_requests WHERE request_id = $1`, requestID)
+ require.NoError(t, err)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_notifications WHERE kind = 'friend_request'`).Scan(&count))
+ require.Zero(t, count)
+ _, err = tx.ExecContext(ctx, string(down))
+ require.NoError(t, err)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_messages WHERE kind = 'friend_added'`).Scan(&count))
+ require.Equal(t, 2, count)
+}
diff --git a/server/space/repo/friends.go b/server/space/repo/friends.go
index 16545a0c18..62a2d5e2fd 100644
--- a/server/space/repo/friends.go
+++ b/server/space/repo/friends.go
@@ -68,24 +68,20 @@ func upsertFriendShare(ctx context.Context, execer friendShareExecer, share frie
return stacktrace.Propagate(err, "")
}
-func insertFriendAddedActivityTx(ctx context.Context, tx *sql.Tx, senderSpaceID string, recipientSpaceID string) (int64, error) {
- var createdAt int64
- if err := tx.QueryRowContext(ctx, `
- INSERT INTO space_messages (
- message_id,
- sender_space_id,
- recipient_space_id,
- kind
- )
- VALUES ($1, $2, $3, 'friend_added')
- RETURNING created_at
- `, base.MustNewID("wmsg"), senderSpaceID, recipientSpaceID).Scan(&createdAt); err != nil {
- return 0, stacktrace.Propagate(err, "")
- }
- if err := upsertNotificationReadMarker(ctx, tx, senderSpaceID, recipientSpaceID, createdAt); err != nil {
- return 0, err
+func completeFriendRequestNotificationsTx(ctx context.Context, tx *sql.Tx, actorSpaceID string, recipientSpaceID string) error {
+ if _, err := tx.ExecContext(ctx, `
+ UPDATE space_notifications
+ SET kind = 'friend_accepted', friend_request_id = NULL,
+ created_at = now_utc_micro_seconds(), read_at = now_utc_micro_seconds()
+ WHERE kind = 'friend_request' AND recipient_space_id = $1 AND actor_space_id = $2
+ `, actorSpaceID, recipientSpaceID); err != nil {
+ return stacktrace.Propagate(err, "")
}
- return createdAt, nil
+ _, err := tx.ExecContext(ctx, `
+ INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind)
+ VALUES ($1, $2, $3, 'friend_accepted')
+ `, base.MustNewID("wnot"), recipientSpaceID, actorSpaceID)
+ return stacktrace.Propagate(err, "")
}
func (r *FriendsRepository) CreateFriendRequest(ctx context.Context, requesterID int64, requesterSpaceID string, targetSpaceID string, requesterFriendSealedSpaceKey []byte, requesterKeyVersion int) (*SpaceFriendRequestRecord, bool, bool, error) {
@@ -195,12 +191,12 @@ func (r *FriendsRepository) CreateFriendRequest(ctx context.Context, requesterID
); err != nil {
return nil, false, false, err
}
+ if err := completeFriendRequestNotificationsTx(ctx, tx, requesterSpaceID, targetSpaceID); err != nil {
+ return nil, false, false, err
+ }
if _, err := tx.ExecContext(ctx, `DELETE FROM space_friend_requests WHERE request_id = $1`, reverse.RequestID); err != nil {
return nil, false, false, stacktrace.Propagate(err, "")
}
- if _, err := insertFriendAddedActivityTx(ctx, tx, requesterSpaceID, targetSpaceID); err != nil {
- return nil, false, false, err
- }
reverse.RequesterID = targetOwnerID
reverse.RequesterSpaceID = targetSpaceID
reverse.TargetID = requesterID
@@ -246,6 +242,12 @@ func (r *FriendsRepository) CreateFriendRequest(ctx context.Context, requesterID
`, requesterSpaceID, targetSpaceID, requesterFriendSealedSpaceKey, requesterKeyVersion).Scan(&rec.RequestID, &rec.CreatedAt); err != nil {
return nil, false, false, stacktrace.Propagate(err, "")
}
+ if _, err := tx.ExecContext(ctx, `
+ INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, friend_request_id, created_at)
+ VALUES ($1, $2, $3, 'friend_request', $4, $5)
+ `, base.MustNewID("wnot"), targetSpaceID, requesterSpaceID, rec.RequestID, rec.CreatedAt); err != nil {
+ return nil, false, false, stacktrace.Propagate(err, "")
+ }
rec.RequesterID = requesterID
rec.RequesterSpaceID = requesterSpaceID
rec.TargetID = targetOwnerID
@@ -383,6 +385,11 @@ func (r *FriendsRepository) ConfirmFriendRequest(ctx context.Context, targetSpac
return 0, false, err
}
+ if !alreadyFriends {
+ if err := completeFriendRequestNotificationsTx(ctx, tx, targetSpaceID, requesterSpaceID); err != nil {
+ return 0, false, err
+ }
+ }
if _, err := tx.ExecContext(ctx, `
DELETE FROM space_friend_requests
WHERE request_id = $1
@@ -390,11 +397,6 @@ func (r *FriendsRepository) ConfirmFriendRequest(ctx context.Context, targetSpac
`, requestID, targetSpaceID, requesterSpaceID); err != nil {
return 0, false, stacktrace.Propagate(err, "")
}
- if !alreadyFriends {
- if _, err := insertFriendAddedActivityTx(ctx, tx, targetSpaceID, requesterSpaceID); err != nil {
- return 0, false, err
- }
- }
if err := tx.Commit(); err != nil {
return 0, false, stacktrace.Propagate(err, "")
@@ -497,6 +499,12 @@ func (r *FriendsRepository) DeleteFriendship(ctx context.Context, actorSpaceID s
`, targetSpaceID, actorSpaceID); err != nil {
return stacktrace.Propagate(err, "")
}
+ if _, err := tx.ExecContext(ctx, `
+ DELETE FROM space_notifications WHERE kind IN ('friend_accepted', 'poke')
+ AND ((recipient_space_id = $1 AND actor_space_id = $2) OR (recipient_space_id = $2 AND actor_space_id = $1))
+ `, actorSpaceID, targetSpaceID); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
return stacktrace.Propagate(tx.Commit(), "")
}
diff --git a/server/space/repo/messages.go b/server/space/repo/messages.go
index f9e9c8c66b..3863ec9c44 100644
--- a/server/space/repo/messages.go
+++ b/server/space/repo/messages.go
@@ -32,12 +32,7 @@ const spaceMessageBaseSelectColumns = `
m.is_deleted,
m.created_at,
m.updated_at,
- CASE
- WHEN m.kind = 'post_like' AND m.sender_space_id = %[1]s THEN 'You liked a post'
- WHEN m.kind = 'post_like' THEN 'Liked your post'
- WHEN m.kind = 'friend_added' THEN 'You are now friends'
- ELSE ''
- END AS text
+ '' AS text
`
func spaceMessageSelectColumns(viewerPlaceholder string) string {
@@ -102,19 +97,15 @@ FROM (
ELSE m.sender_space_id
END AS friend_space_id,
CASE
- WHEN m.kind = 'post_like' THEN 'post_like'
- WHEN m.kind = 'friend_added' THEN 'friend_added'
WHEN m.kind = 'post_reply' AND m.recipient_space_id = $1 THEN 'post_reply'
ELSE 'message'
END AS activity_type,
CASE
- WHEN m.kind = 'post_like' THEN 'post_like:' || m.reply_post_id || ':' || m.sender_space_id
- WHEN m.kind = 'friend_added' THEN 'friend_added:' || m.message_id
WHEN m.kind = 'post_reply' AND m.recipient_space_id = $1 THEN 'post_reply:' || m.message_id
ELSE 'message:' || m.message_id
END AS activity_id,
m.created_at AS activity_created_at,
- CASE WHEN m.kind = 'post_like' THEN NULL::text ELSE m.message_id END AS message_id,
+ m.message_id,
m.reply_post_id AS post_id,
m.recipient_space_id AS post_space_id,
m.kind AS message_kind,
@@ -128,12 +119,12 @@ FROM (
NULL::bytea AS encrypted_reaction,
m.reply_message_id,
CASE
- WHEN m.recipient_space_id = $1 AND m.kind IN ('regular', 'post_reply', 'post_like', 'friend_added') THEN m.created_at
+ WHEN m.recipient_space_id = $1 AND m.kind IN ('regular', 'post_reply') THEN m.created_at
ELSE NULL::bigint
END AS notification_created_at,
(m.sender_space_id = $1) AS is_outgoing
FROM peer_messages m
- WHERE m.kind IN ('regular', 'post_reply', 'post_like', 'friend_added')
+ WHERE m.kind IN ('regular', 'post_reply')
UNION ALL
diff --git a/server/space/repo/module.go b/server/space/repo/module.go
index 0bdb9f9a49..050b89b328 100644
--- a/server/space/repo/module.go
+++ b/server/space/repo/module.go
@@ -7,16 +7,18 @@ import (
)
type Module struct {
- Spaces *SpacesRepository
- Posts *PostsRepository
- Friends *FriendsRepository
- Messages *MessagesRepository
- Assets *AssetsRepository
- Read *ReadMarkersRepository
- Sessions *SessionsRepository
- Drips *DripsRepository
- Links *LinksRepository
- WebPush *WebPushRepository
+ Spaces *SpacesRepository
+ Posts *PostsRepository
+ Friends *FriendsRepository
+ Messages *MessagesRepository
+ Assets *AssetsRepository
+ Read *ReadMarkersRepository
+ Sessions *SessionsRepository
+ Drips *DripsRepository
+ Links *LinksRepository
+ WebPush *WebPushRepository
+ Notifications *NotificationsRepository
+ Pokes *PokesRepository
}
type SpacesRepository struct {
@@ -266,15 +268,17 @@ type SpaceWebPushSubscriptionRecord struct {
func NewModule(db *sql.DB, s3Config *s3config.S3Config) *Module {
return &Module{
- Spaces: &SpacesRepository{DB: db},
- Posts: &PostsRepository{DB: db},
- Friends: &FriendsRepository{DB: db},
- Messages: &MessagesRepository{DB: db},
- Assets: &AssetsRepository{DB: db, S3Config: s3Config},
- Read: &ReadMarkersRepository{DB: db},
- Sessions: &SessionsRepository{DB: db},
- Drips: &DripsRepository{DB: db},
- Links: &LinksRepository{DB: db},
- WebPush: &WebPushRepository{DB: db},
+ Spaces: &SpacesRepository{DB: db},
+ Posts: &PostsRepository{DB: db},
+ Friends: &FriendsRepository{DB: db},
+ Messages: &MessagesRepository{DB: db},
+ Assets: &AssetsRepository{DB: db, S3Config: s3Config},
+ Read: &ReadMarkersRepository{DB: db},
+ Sessions: &SessionsRepository{DB: db},
+ Drips: &DripsRepository{DB: db},
+ Links: &LinksRepository{DB: db},
+ WebPush: &WebPushRepository{DB: db},
+ Notifications: &NotificationsRepository{DB: db},
+ Pokes: &PokesRepository{DB: db},
}
}
diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.go
index 35d6bcf5ae..e7740ed133 100644
--- a/server/space/repo/module_test.go
+++ b/server/space/repo/module_test.go
@@ -139,12 +139,11 @@ func testAddFriend(ctx context.Context, module *Module, requesterID int64, reque
return err
}
res, err := module.Messages.DB.ExecContext(ctx, `
- UPDATE space_messages
- SET created_at = 1, updated_at = 1
- WHERE kind = 'friend_added'
+ DELETE FROM space_notifications
+ WHERE kind = 'friend_accepted'
AND (
- (sender_space_id = $1 AND recipient_space_id = $2)
- OR (sender_space_id = $2 AND recipient_space_id = $1)
+ (actor_space_id = $1 AND recipient_space_id = $2)
+ OR (actor_space_id = $2 AND recipient_space_id = $1)
)
`, requesterSpaceID, targetSpaceID)
if err != nil {
@@ -679,7 +678,7 @@ func TestSpaceAccountDeletionResetAccountDeletionAccess(t *testing.T) {
require.Equal(t, int64(2), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1 OR friend_space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE requester_space_id = $1 OR target_space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(2), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notification_read_markers WHERE viewer_space_id = $1 OR friend_space_id = $1`, aliceSpace.SpaceID))
- require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_messages WHERE kind = 'post_like' AND reply_post_id = $1`, postID))
+ require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_post_likes WHERE post_id = $1`, postID))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_messages WHERE message_id = $1 AND recipient_liked_at IS NOT NULL`, message.MessageID))
_, _, err = testConfirmFriendRequest(ctx, module, charlieID, charlieSpace.SpaceID, pendingRequest.RequestID, "charlie-share-key", charlieSpace.CurrentVersion)
require.NoError(t, err)
@@ -829,7 +828,7 @@ func TestSpaceMessagesThreadAndConversations(t *testing.T) {
aliceThread, nextCursor, err := module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
- require.Len(t, aliceThread, 3)
+ require.Len(t, aliceThread, 2)
require.Equal(t, reply.MessageID, aliceThread[0].MessageID)
require.Equal(t, message.MessageID, aliceThread[0].ReplyMessageID.String)
require.Equal(t, testSpaceBytes("recipient-key"), aliceThread[1].EncryptedMessageKey)
@@ -854,7 +853,7 @@ func TestSpaceMessagesThreadAndConversations(t *testing.T) {
aliceThread, nextCursor, err = module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
- require.Len(t, aliceThread, 2)
+ require.Len(t, aliceThread, 1)
require.Equal(t, reply.MessageID, aliceThread[0].MessageID)
require.Equal(t, message.MessageID, aliceThread[0].ReplyMessageID.String)
@@ -903,7 +902,7 @@ func TestSpaceConversationsUseProfileAssetAvatars(t *testing.T) {
thread, nextCursor, err := module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
- require.Len(t, thread, 2)
+ require.Len(t, thread, 1)
require.Equal(t, bobSpace.SpaceID, thread[0].SenderSpaceID)
require.Equal(t, aliceSpace.SpaceID, thread[0].RecipientSpaceID)
@@ -935,8 +934,8 @@ func TestSpaceMessageConversationsUseLatestActivity(t *testing.T) {
require.Empty(t, nextCursor)
require.Len(t, conversations, 1)
require.Equal(t, bobSpace.SpaceID, conversations[0].Friend.SpaceID)
- require.Equal(t, "friend_added", conversations[0].LatestActivity.Type)
- require.True(t, conversations[0].LatestActivity.MessageID.Valid)
+ require.Equal(t, "empty", conversations[0].LatestActivity.Type)
+ require.False(t, conversations[0].LatestActivity.MessageID.Valid)
require.False(t, conversations[0].Unread)
require.Zero(t, conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
@@ -992,9 +991,8 @@ func TestSpaceMessageConversationsUseLatestActivity(t *testing.T) {
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
- require.Equal(t, "post_like", conversations[0].LatestActivity.Type)
- require.True(t, conversations[0].LatestActivity.PostID.Valid)
- require.Equal(t, postID, conversations[0].LatestActivity.PostID.Int64)
+ require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
+ require.Equal(t, bobMessage.MessageID, conversations[0].LatestActivity.MessageID.String)
postReply, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "post_reply",
@@ -1062,7 +1060,7 @@ func TestSpaceMessageConversationsUseLatestActivity(t *testing.T) {
require.Empty(t, conversations)
}
-func TestCurrentFriendsWithoutMessagesUseFriendAddedActivity(t *testing.T) {
+func TestCurrentFriendsWithoutMessagesHaveNoActivity(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
@@ -1082,16 +1080,16 @@ func TestCurrentFriendsWithoutMessagesUseFriendAddedActivity(t *testing.T) {
require.Empty(t, nextCursor)
require.Len(t, conversations, 1)
require.Equal(t, bobSpace.SpaceID, conversations[0].Friend.SpaceID)
- require.Equal(t, "friend_added", conversations[0].LatestActivity.Type)
- require.Equal(t, int64(1), conversations[0].LatestActivity.CreatedAt)
- require.True(t, conversations[0].LatestActivity.MessageID.Valid)
+ require.Equal(t, "empty", conversations[0].LatestActivity.Type)
+ require.Equal(t, int64(1000), conversations[0].LatestActivity.CreatedAt)
+ require.False(t, conversations[0].LatestActivity.MessageID.Valid)
require.False(t, conversations[0].Unread)
require.Zero(t, conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
latestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
- require.Equal(t, int64(1), latestActivityAt)
+ require.Zero(t, latestActivityAt)
require.NoError(t, module.Friends.DeleteFriendship(ctx, aliceSpace.SpaceID, bobSpace.SpaceID))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
@@ -1132,15 +1130,12 @@ func TestLatestChatSummariesUseCurrentFriendActivities(t *testing.T) {
summaries, err := module.Messages.ListLatestChatSummaries(ctx, aliceSpace.SpaceID, []string{bobSpace.SpaceID, charlieSpace.SpaceID})
require.NoError(t, err)
- require.Len(t, summaries, 2)
- charlieSummary := summaries[charlieSpace.SpaceID]
- require.Equal(t, "friend_added", charlieSummary.LatestActivity.Type)
- require.Empty(t, charlieSummary.UnreadActivities)
+ require.Len(t, summaries, 1)
+ require.NotContains(t, summaries, charlieSpace.SpaceID)
bobSummary := summaries[bobSpace.SpaceID]
- require.Equal(t, "post_like", bobSummary.LatestActivity.Type)
- require.True(t, bobSummary.LatestActivity.PostID.Valid)
- require.Equal(t, postID, bobSummary.LatestActivity.PostID.Int64)
- require.Len(t, bobSummary.UnreadActivities, 2)
+ require.Equal(t, "message", bobSummary.LatestActivity.Type)
+ require.Equal(t, bobMessage.MessageID, bobSummary.LatestActivity.MessageID.String)
+ require.Len(t, bobSummary.UnreadActivities, 1)
for _, activity := range bobSummary.UnreadActivities {
require.Empty(t, activity.MessageCipher)
require.Empty(t, activity.EncryptedMessageKey)
@@ -1152,7 +1147,7 @@ func TestLatestChatSummariesUseCurrentFriendActivities(t *testing.T) {
require.NoError(t, err)
bobSummary = summaries[bobSpace.SpaceID]
require.Empty(t, bobSummary.UnreadActivities)
- require.Equal(t, "post_like", bobSummary.LatestActivity.Type)
+ require.Equal(t, "message", bobSummary.LatestActivity.Type)
require.NoError(t, module.Friends.DeleteFriendship(ctx, aliceSpace.SpaceID, bobSpace.SpaceID))
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
@@ -1174,7 +1169,7 @@ func TestConfirmFriendRequestCreatesFriendshipAndNotifiesRequester(t *testing.T)
request, created, err := testCreateFriendRequest(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
- aliceUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
+ aliceUnread, err := module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, aliceUnread)
@@ -1192,20 +1187,20 @@ func TestConfirmFriendRequestCreatesFriendshipAndNotifiesRequester(t *testing.T)
requests, err := module.Friends.ListFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, requests)
- aliceUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
+ aliceUnread, err = module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, aliceUnread)
bobRequests, err := module.Friends.ListFriendRequestsForSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, bobRequests)
- bobUnread, err := module.Read.HasUnreadNotifications(ctx, bobSpace.SpaceID)
+ bobUnread, err := module.Notifications.HasUnread(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.True(t, bobUnread)
aliceConversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, aliceConversations, 1)
require.Equal(t, bobSpace.SpaceID, aliceConversations[0].Friend.SpaceID)
- require.Equal(t, "friend_added", aliceConversations[0].LatestActivity.Type)
+ require.Equal(t, "empty", aliceConversations[0].LatestActivity.Type)
require.False(t, aliceConversations[0].NotificationUnread)
require.False(t, aliceConversations[0].Unread)
require.Zero(t, aliceConversations[0].UnreadCount)
@@ -1213,11 +1208,11 @@ func TestConfirmFriendRequestCreatesFriendshipAndNotifiesRequester(t *testing.T)
require.NoError(t, err)
require.Len(t, bobConversations, 1)
require.Equal(t, aliceSpace.SpaceID, bobConversations[0].Friend.SpaceID)
- require.Equal(t, "friend_added", bobConversations[0].LatestActivity.Type)
- require.True(t, bobConversations[0].NotificationUnread)
+ require.Equal(t, "empty", bobConversations[0].LatestActivity.Type)
+ require.False(t, bobConversations[0].NotificationUnread)
require.False(t, bobConversations[0].Unread)
require.Zero(t, bobConversations[0].UnreadCount)
- require.Len(t, bobConversations[0].UnreadActivities, 1)
+ require.Empty(t, bobConversations[0].UnreadActivities)
}
func TestReciprocalFriendRequestAutoConfirms(t *testing.T) {
@@ -1252,10 +1247,10 @@ func TestReciprocalFriendRequestAutoConfirms(t *testing.T) {
bobRequests, err := module.Friends.ListFriendRequestsForSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, bobRequests)
- aliceUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
+ aliceUnread, err := module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, aliceUnread)
- bobUnread, err := module.Read.HasUnreadNotifications(ctx, bobSpace.SpaceID)
+ bobUnread, err := module.Notifications.HasUnread(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.True(t, bobUnread)
}
@@ -1274,12 +1269,12 @@ func TestDeleteFriendRequestClearsUnread(t *testing.T) {
request, created, err := testCreateFriendRequest(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
- aliceUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
+ aliceUnread, err := module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, aliceUnread)
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, aliceSpace.SpaceID, request.RequestID))
- aliceUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
+ aliceUnread, err = module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, aliceUnread)
requests, err := module.Friends.ListFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
@@ -1352,7 +1347,7 @@ func TestFriendRequestsStayOutOfMessageConversations(t *testing.T) {
require.Equal(t, bobSpace.SpaceID, requests[0].Requester.SpaceID)
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
- require.True(t, notificationsUnread)
+ require.False(t, notificationsUnread)
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, aliceSpace.SpaceID, request.RequestID))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
@@ -1422,7 +1417,7 @@ func TestSpaceMessageConversationPreviewUsesLatestActivityWithSeparateUnreadStat
require.Equal(t, aliceOldMessage.MessageID, conversations[0].LatestActivity.MessageID.String)
}
-func TestPostLikeUnreadCountSuppression(t *testing.T) {
+func TestPostLikesDoNotAffectMessageUnreadState(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
@@ -1457,32 +1452,32 @@ func TestPostLikeUnreadCountSuppression(t *testing.T) {
conversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, conversations, 1)
- require.Equal(t, "post_like", conversations[0].LatestActivity.Type)
+ require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
- require.True(t, conversations[0].NotificationUnread)
+ require.False(t, conversations[0].NotificationUnread)
require.NoError(t, testSetPostLike(ctx, module, secondPostID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 3000, secondPostID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
- require.Equal(t, "post_like", conversations[0].LatestActivity.Type)
+ require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
- require.True(t, conversations[0].NotificationUnread)
+ require.False(t, conversations[0].NotificationUnread)
latestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
- require.Equal(t, int64(3000), latestActivityAt)
+ require.Equal(t, int64(1000), latestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, latestActivityAt))
require.NoError(t, testSetPostLike(ctx, module, thirdPostID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 4000, thirdPostID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
- require.Equal(t, "post_like", conversations[0].LatestActivity.Type)
+ require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
- require.True(t, conversations[0].NotificationUnread)
+ require.False(t, conversations[0].NotificationUnread)
require.NoError(t, module.Messages.SetLike(ctx, aliceMessage.MessageID, bobSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 5000, aliceMessage.MessageID, bobSpace.SpaceID)
@@ -1659,14 +1654,14 @@ func TestSpaceModuleLifecycle(t *testing.T) {
requireQueuedTempObject(t, module, "space/alice/post1/full", TempObjectPurposePost, "b2-eu-cen")
requireQueuedTempObject(t, module, "space/alice/post1/thumb", TempObjectPurposePost, "b2-eu-cen")
var likeCount int
- err = module.Posts.DB.QueryRow(`SELECT COUNT(*) FROM space_messages WHERE kind = 'post_like' AND reply_post_id = $1`, postID).Scan(&likeCount)
+ err = module.Posts.DB.QueryRow(`SELECT COUNT(*) FROM space_post_likes WHERE post_id = $1`, postID).Scan(&likeCount)
require.NoError(t, err)
- require.Equal(t, 1, likeCount)
+ require.Equal(t, 0, likeCount)
require.NoError(t, module.Posts.DeletePost(ctx, postID, aliceSpace.SpaceID))
- err = module.Posts.DB.QueryRow(`SELECT COUNT(*) FROM space_messages WHERE kind = 'post_like' AND reply_post_id = $1`, postID).Scan(&likeCount)
+ err = module.Posts.DB.QueryRow(`SELECT COUNT(*) FROM space_post_likes WHERE post_id = $1`, postID).Scan(&likeCount)
require.NoError(t, err)
- require.Equal(t, 1, likeCount)
+ require.Equal(t, 0, likeCount)
_, err = module.Posts.GetPost(ctx, postID, bobSpace.SpaceID)
require.Error(t, err)
@@ -2509,43 +2504,36 @@ func TestUnreadNotificationsTrackReadableActivityWithoutChangingLatestPreview(t
require.Equal(t, int64(4000), conversations[0].SortCreatedAt)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
- require.True(t, conversations[0].NotificationUnread)
+ require.False(t, conversations[0].NotificationUnread)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
- require.True(t, notificationsUnread)
+ require.False(t, notificationsUnread)
require.NoError(t, testSetPostLike(ctx, module, bobPostID, aliceSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 4500, bobPostID, aliceSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
- require.Equal(t, "post_like", conversations[0].LatestActivity.Type)
+ require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.True(t, conversations[0].LatestActivity.Outgoing)
require.True(t, conversations[0].LatestActivity.PostID.Valid)
require.Equal(t, bobPostID, conversations[0].LatestActivity.PostID.Int64)
- require.Equal(t, int64(4500), conversations[0].SortCreatedAt)
+ require.Equal(t, int64(4000), conversations[0].SortCreatedAt)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
- require.True(t, conversations[0].NotificationUnread)
+ require.False(t, conversations[0].NotificationUnread)
latestActivityAt, err = module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
- require.Equal(t, int64(4500), latestActivityAt)
+ require.Equal(t, int64(4000), latestActivityAt)
thread, _, err := module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
- require.GreaterOrEqual(t, len(thread), 3)
- require.Equal(t, "post_like", thread[0].Kind)
- require.Equal(t, "You liked a post", thread[0].Text)
- require.True(t, thread[0].ReplyPostID.Valid)
- require.Equal(t, bobPostID, thread[0].ReplyPostID.Int64)
- require.Equal(t, bobSpace.SpaceID, thread[0].RecipientSpaceID)
- require.Equal(t, "post_reply", thread[1].Kind)
- require.Equal(t, outgoingPostReply.MessageID, thread[1].MessageID)
- require.Equal(t, "post_like", thread[2].Kind)
- require.Equal(t, "Liked your post", thread[2].Text)
- require.True(t, thread[2].ReplyPostID.Valid)
- require.Equal(t, alicePostID, thread[2].ReplyPostID.Int64)
- require.Equal(t, aliceSpace.SpaceID, thread[2].RecipientSpaceID)
+ require.GreaterOrEqual(t, len(thread), 1)
+ require.Equal(t, "post_reply", thread[0].Kind)
+ require.Equal(t, outgoingPostReply.MessageID, thread[0].MessageID)
+ for _, message := range thread {
+ require.NotEqual(t, "post_like", message.Kind)
+ }
incomingPostReply, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "post_reply",
@@ -2586,9 +2574,9 @@ func TestUnreadNotificationsTrackReadableActivityWithoutChangingLatestPreview(t
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
- require.Equal(t, "post_like", conversations[0].LatestActivity.Type)
+ require.Equal(t, "post_reply", conversations[0].LatestActivity.Type)
require.Equal(t, alicePostID, conversations[0].LatestActivity.PostID.Int64)
- require.Equal(t, int64(6000), conversations[0].SortCreatedAt)
+ require.Equal(t, int64(5001), conversations[0].SortCreatedAt)
require.True(t, conversations[0].Unread)
require.Equal(t, int64(2), conversations[0].UnreadCount)
require.True(t, conversations[0].NotificationUnread)
@@ -2598,7 +2586,7 @@ func TestUnreadNotificationsTrackReadableActivityWithoutChangingLatestPreview(t
latestActivityAt, err = module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
- require.Equal(t, int64(6000), latestActivityAt)
+ require.Equal(t, int64(5001), latestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, latestActivityAt))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
@@ -2647,7 +2635,7 @@ func setPostCreatedAt(t *testing.T, module *Module, createdAt int64, postIDs ...
func setPostLikeCreatedAt(t *testing.T, module *Module, createdAt, postID int64, actorSpaceID string) {
t.Helper()
- _, err := module.Posts.DB.Exec(`UPDATE space_messages SET created_at = $1, updated_at = $1 WHERE kind = 'post_like' AND reply_post_id = $2 AND sender_space_id = $3`, createdAt, postID, actorSpaceID)
+ _, err := module.Posts.DB.Exec(`UPDATE space_post_likes SET created_at = $1 WHERE post_id = $2 AND actor_space_id = $3`, createdAt, postID, actorSpaceID)
require.NoError(t, err)
}
diff --git a/server/space/repo/notifications.go b/server/space/repo/notifications.go
new file mode 100644
index 0000000000..22d0782b68
--- /dev/null
+++ b/server/space/repo/notifications.go
@@ -0,0 +1,135 @@
+package repo
+
+import (
+ "context"
+ "database/sql"
+ "strconv"
+
+ "github.com/ente/stacktrace"
+ "github.com/lib/pq"
+)
+
+type NotificationsRepository struct {
+ DB *sql.DB
+}
+
+type SpaceNotificationRecord struct {
+ NotificationID string
+ Kind string
+ Actors []SpaceActorRecord
+ ActorCount int64
+ PostID sql.NullInt64
+ FriendRequestID sql.NullInt64
+ CreatedAt int64
+ Unread bool
+}
+
+const notificationSourcesSQL = `
+ FROM space_notifications n
+ LEFT 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
+ JOIN spaces actor ON actor.space_id = n.actor_space_id
+ JOIN 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.kind IN ('friend_accepted', 'poke') OR p.post_id IS NOT NULL)
+ AND EXISTS (SELECT 1 FROM space_friend_shares share
+ WHERE share.space_id = n.recipient_space_id AND share.friend_space_id = n.actor_space_id)
+ ))
+`
+
+func (r *NotificationsRepository) List(ctx context.Context, recipientSpaceID, cursor string, limit int) ([]SpaceNotificationRecord, string, error) {
+ limit = optionalInt(limit, 50)
+ if limit > 100 {
+ limit = 100
+ }
+ query := `WITH visible AS (
+ SELECT n.*, l.post_id, CASE
+ WHEN n.kind = 'post_like' THEN l.post_id::text
+ WHEN n.kind IN ('friend_accepted', 'poke') THEN n.actor_space_id
+ ELSE n.notification_id
+ END 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,
+ CASE WHEN kind = 'post_like' THEN COUNT(*) OVER (PARTITION BY kind, group_id) ELSE 1 END AS actor_count,
+ BOOL_OR(read_at IS NULL) OVER (PARTITION BY kind, group_id) AS unread,
+ ROW_NUMBER() OVER (PARTITION BY kind, group_id ORDER BY created_at DESC, notification_id DESC) AS position
+ FROM visible
+ ), page AS (
+ SELECT * FROM ranked WHERE position = 1`
+ args := []any{recipientSpaceID}
+ if createdAt, id, ok := parseMessageCursor(cursor); ok {
+ query += ` AND (created_at, notification_id) < ($2, $3)`
+ args = append(args, createdAt, id)
+ }
+ args = append(args, limit+1)
+ query += ` ORDER BY created_at DESC, notification_id DESC LIMIT $` + strconv.Itoa(len(args)) + `
+ )
+ SELECT page.notification_id, page.kind, page.post_id, page.friend_request_id, page.created_at, page.actor_count, page.unread, ` + spaceActorSelectColumns("actor", "avatar", "actor") + `
+ FROM page
+ 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 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`
+ rows, err := r.DB.QueryContext(ctx, query, args...)
+ if err != nil {
+ return nil, "", stacktrace.Propagate(err, "")
+ }
+ defer rows.Close()
+ items := make([]SpaceNotificationRecord, 0)
+ for rows.Next() {
+ var item SpaceNotificationRecord
+ var actor SpaceActorRecord
+ dest := []any{&item.NotificationID, &item.Kind, &item.PostID, &item.FriendRequestID, &item.CreatedAt, &item.ActorCount, &item.Unread}
+ dest = append(dest, spaceActorScanDest(&actor)...)
+ if err := rows.Scan(dest...); err != nil {
+ return nil, "", stacktrace.Propagate(err, "")
+ }
+ if len(items) == 0 || items[len(items)-1].NotificationID != item.NotificationID {
+ items = append(items, item)
+ }
+ last := &items[len(items)-1]
+ last.Actors = append(last.Actors, actor)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, "", stacktrace.Propagate(err, "")
+ }
+ nextCursor := ""
+ if len(items) > limit {
+ last := items[limit-1]
+ nextCursor = strconv.FormatInt(last.CreatedAt, 10) + ":" + last.NotificationID
+ items = items[:limit]
+ }
+ return items, nextCursor, nil
+}
+
+func (r *NotificationsRepository) HasUnread(ctx context.Context, recipientSpaceID string) (bool, error) {
+ var unread bool
+ err := r.DB.QueryRowContext(ctx, `SELECT EXISTS (SELECT 1 `+notificationSourcesSQL+` WHERE n.recipient_space_id = $1 AND n.read_at IS NULL AND `+notificationVisibleSQL+`)`, recipientSpaceID).Scan(&unread)
+ return unread, stacktrace.Propagate(err, "")
+}
+
+func (r *NotificationsRepository) MarkRead(ctx context.Context, recipientSpaceID string, notificationIDs []string) error {
+ _, err := r.DB.ExecContext(ctx, `
+ WITH visible AS (
+ SELECT n.notification_id, n.kind, n.actor_space_id, l.post_id, n.created_at
+ `+notificationSourcesSQL+` WHERE n.recipient_space_id = $1 AND `+notificationVisibleSQL+`
+ )
+ UPDATE space_notifications n SET read_at = now_utc_micro_seconds()
+ FROM visible item, visible anchor
+ WHERE n.notification_id = item.notification_id AND n.read_at IS NULL
+ AND anchor.notification_id = ANY($2)
+ AND (item.notification_id = anchor.notification_id OR (
+ item.kind = anchor.kind AND (
+ (item.kind = 'post_like' AND item.post_id = anchor.post_id)
+ OR (item.kind IN ('friend_accepted', 'poke') AND item.actor_space_id = anchor.actor_space_id)
+ )
+ AND (item.created_at, item.notification_id) <= (anchor.created_at, anchor.notification_id)
+ ))
+ `, recipientSpaceID, pq.Array(notificationIDs))
+ return stacktrace.Propagate(err, "")
+}
diff --git a/server/space/repo/notifications_test.go b/server/space/repo/notifications_test.go
new file mode 100644
index 0000000000..951bbf2199
--- /dev/null
+++ b/server/space/repo/notifications_test.go
@@ -0,0 +1,294 @@
+package repo
+
+import (
+ "database/sql"
+ "fmt"
+ "os"
+ "sync"
+ "testing"
+
+ "github.com/lib/pq"
+ "github.com/stretchr/testify/require"
+)
+
+func notificationTestSpaces(t *testing.T, module *Module) (*SpaceRecord, *SpaceRecord) {
+ t.Helper()
+ ctx := t.Context()
+ aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
+ bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
+ alice, err := testCreateSpace(ctx, module, aliceID, "alice_notifications", "root", "alice-public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ bob, err := testCreateSpace(ctx, module, bobID, "bob_notifications", "root", "bob-public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ require.NoError(t, testAddFriend(ctx, module, bobID, bob.SpaceID, alice.SpaceID, "alice-share", 1, "bob-share", 1))
+ return alice, bob
+}
+
+func TestPostLikeNotificationLifecycle(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ postID, err := testCreatePost(ctx, module, alice.OwnerID, alice.SpaceID, "post-key", nil, 1, nil)
+ require.NoError(t, err)
+ var workers sync.WaitGroup
+ results := make(chan bool, 8)
+ errors := make(chan error, 8)
+ for range 8 {
+ workers.Add(1)
+ go func() {
+ defer workers.Done()
+ created, err := module.Posts.SetLikeWithCreated(ctx, postID, bob.SpaceID, true)
+ results <- created
+ errors <- err
+ }()
+ }
+ workers.Wait()
+ close(results)
+ close(errors)
+ createdCount := 0
+ for created := range results {
+ if created {
+ createdCount++
+ }
+ }
+ for err := range errors {
+ require.NoError(t, err)
+ }
+ require.Equal(t, 1, createdCount)
+ items, cursor, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Empty(t, cursor)
+ require.Len(t, items, 1)
+ require.Equal(t, bob.SpaceID, items[0].Actors[0].SpaceID)
+ require.Equal(t, postID, items[0].PostID.Int64)
+ require.True(t, items[0].Unread)
+ originalID := items[0].NotificationID
+ unread, err := module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.True(t, unread)
+ messagesUnread, err := module.Read.HasUnreadNotifications(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, messagesUnread)
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_messages WHERE kind = 'post_like'`))
+ post, err := module.Posts.GetPost(ctx, postID, bob.SpaceID)
+ require.NoError(t, err)
+ require.True(t, post.ViewerLiked)
+
+ require.NoError(t, module.Notifications.MarkRead(ctx, bob.SpaceID, []string{originalID}))
+ unread, err = module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.True(t, unread)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{originalID}))
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{originalID}))
+ unread, err = module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, unread)
+ var marker int64
+ require.NoError(t, module.Read.DB.QueryRow(`SELECT read_at FROM space_notification_read_markers WHERE viewer_space_id = $1 AND friend_space_id = $2`, alice.SpaceID, bob.SpaceID).Scan(&marker))
+ require.Equal(t, int64(1), marker)
+
+ _, err = module.Posts.SetLikeWithCreated(ctx, postID, bob.SpaceID, false)
+ require.NoError(t, err)
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications`))
+ post, err = module.Posts.GetPost(ctx, postID, bob.SpaceID)
+ require.NoError(t, err)
+ require.False(t, post.ViewerLiked)
+ _, err = module.Posts.SetLikeWithCreated(ctx, postID, bob.SpaceID, true)
+ require.NoError(t, err)
+ items, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Len(t, items, 1)
+ require.NotEqual(t, originalID, items[0].NotificationID)
+ require.True(t, items[0].Unread)
+ require.NoError(t, module.Posts.DeletePost(ctx, postID, alice.SpaceID))
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications`))
+ _, err = module.Posts.SetLikeWithCreated(ctx, postID, bob.SpaceID, true)
+ require.ErrorIs(t, err, sql.ErrNoRows)
+}
+
+func TestNotificationsPaginationAndReadIsolation(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ for range 3 {
+ postID, err := testCreatePost(ctx, module, alice.OwnerID, alice.SpaceID, "post-key", nil, 1, nil)
+ require.NoError(t, err)
+ require.NoError(t, testSetPostLike(ctx, module, postID, bob.SpaceID, true))
+ }
+ _, err := module.Notifications.DB.Exec(`UPDATE space_notifications SET created_at = 1000`)
+ require.NoError(t, err)
+ first, cursor, err := module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.Len(t, first, 2)
+ require.NotEmpty(t, cursor)
+ second, next, err := module.Notifications.List(ctx, alice.SpaceID, cursor, 2)
+ require.NoError(t, err)
+ require.Len(t, second, 1)
+ require.Empty(t, next)
+ require.NotEqual(t, first[0].NotificationID, second[0].NotificationID)
+ require.NotEqual(t, first[1].NotificationID, second[0].NotificationID)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{first[0].NotificationID, first[1].NotificationID}))
+ second, _, err = module.Notifications.List(ctx, alice.SpaceID, cursor, 2)
+ require.NoError(t, err)
+ require.True(t, second[0].Unread)
+ require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, alice.SpaceID, bob.SpaceID, 10000))
+ unread, err := module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.True(t, unread)
+ other, _, err := module.Notifications.List(ctx, bob.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Empty(t, other)
+ require.NoError(t, module.Friends.DeleteFriendship(ctx, alice.SpaceID, bob.SpaceID))
+ hidden, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Empty(t, hidden)
+ unread, err = module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, unread)
+}
+
+func TestNotificationsPaginateCompletePostGroups(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ actors := []*SpaceRecord{bob}
+ for i := 1; i < 25; i++ {
+ ownerID := insertSpaceUser(t, module, fmt.Sprintf("liker-%[email protected]", i), "public")
+ actor, err := testCreateSpace(ctx, module, ownerID, fmt.Sprintf("liker_%d", i), "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ require.NoError(t, testAddFriend(ctx, module, ownerID, actor.SpaceID, alice.SpaceID, "share", 1, "share", 1))
+ actors = append(actors, actor)
+ }
+ posts := make([]int64, 3)
+ for i, count := range []int{25, 2, 1} {
+ postID, err := testCreatePost(ctx, module, alice.OwnerID, alice.SpaceID, "key", nil, 1, nil)
+ require.NoError(t, err)
+ posts[i] = postID
+ for j, actor := range actors[:count] {
+ require.NoError(t, testSetPostLike(ctx, module, postID, actor.SpaceID, true))
+ _, err = module.Notifications.DB.ExecContext(ctx, `
+ UPDATE space_notifications n SET created_at = $1
+ FROM space_post_likes l WHERE l.like_id = n.post_like_id AND l.post_id = $2 AND l.actor_space_id = $3
+ `, (3-i)*1000+j, postID, actor.SpaceID)
+ require.NoError(t, err)
+ }
+ }
+ first, cursor, err := module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.Len(t, first, 2)
+ require.Equal(t, posts[0], first[0].PostID.Int64)
+ require.Equal(t, int64(25), first[0].ActorCount)
+ require.Len(t, first[0].Actors, 2)
+ require.Equal(t, actors[24].SpaceID, first[0].Actors[0].SpaceID)
+ require.Equal(t, actors[23].SpaceID, first[0].Actors[1].SpaceID)
+ require.Equal(t, posts[1], first[1].PostID.Int64)
+ require.Equal(t, int64(2), first[1].ActorCount)
+ require.NotEmpty(t, cursor)
+ second, next, err := module.Notifications.List(ctx, alice.SpaceID, cursor, 2)
+ require.NoError(t, err)
+ require.Len(t, second, 1)
+ require.Equal(t, posts[2], second[0].PostID.Int64)
+ require.Equal(t, int64(1), second[0].ActorCount)
+ require.Len(t, second[0].Actors, 1)
+ require.Empty(t, next)
+ _, err = module.Notifications.DB.ExecContext(ctx, `UPDATE space_notifications SET read_at = 4000 WHERE notification_id = $1`, first[0].NotificationID)
+ require.NoError(t, err)
+ partlyRead, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.True(t, partlyRead[0].Unread)
+
+ require.NoError(t, testSetPostLike(ctx, module, posts[0], bob.SpaceID, false))
+ require.NoError(t, testSetPostLike(ctx, module, posts[0], bob.SpaceID, true))
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{first[0].NotificationID}))
+ updated, _, err := module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.True(t, updated[0].Unread)
+ require.True(t, updated[1].Unread)
+ require.Equal(t, int64(25), updated[0].ActorCount)
+ require.Equal(t, bob.SpaceID, updated[0].Actors[0].SpaceID)
+ require.Equal(t, actors[24].SpaceID, updated[0].Actors[1].SpaceID)
+ require.Equal(t, int64(1), countSpaceRows(t, module, `
+ SELECT COUNT(*) FROM space_notifications n JOIN space_post_likes l ON l.like_id = n.post_like_id
+ WHERE l.post_id = $1 AND n.read_at IS NULL
+ `, posts[0]))
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{updated[0].NotificationID}))
+ updated, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.False(t, updated[0].Unread)
+ require.True(t, updated[1].Unread)
+
+ require.NoError(t, testSetPostLike(ctx, module, posts[0], bob.SpaceID, false))
+ updated, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.Equal(t, int64(24), updated[0].ActorCount)
+ require.Equal(t, actors[24].SpaceID, updated[0].Actors[0].SpaceID)
+ require.False(t, updated[0].Unread)
+ _, err = module.Notifications.DB.ExecContext(ctx, `UPDATE space_notifications SET read_at = NULL WHERE actor_space_id = ANY($1)`, pq.Array([]string{actors[24].SpaceID, actors[23].SpaceID}))
+ require.NoError(t, err)
+ require.NoError(t, module.Friends.DeleteFriendship(ctx, alice.SpaceID, actors[24].SpaceID))
+ _, err = module.Notifications.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, actors[23].OwnerID)
+ require.NoError(t, err)
+ updated, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.Equal(t, int64(22), updated[0].ActorCount)
+ require.Equal(t, actors[22].SpaceID, updated[0].Actors[0].SpaceID)
+ require.False(t, updated[0].Unread)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{updated[0].NotificationID}))
+ require.Equal(t, int64(2), countSpaceRows(t, module, `
+ SELECT COUNT(*) FROM space_notifications n JOIN space_post_likes l ON l.like_id = n.post_like_id
+ WHERE l.post_id = $1 AND n.read_at IS NULL
+ `, posts[0]))
+ require.NoError(t, module.Posts.DeletePost(ctx, posts[0], alice.SpaceID))
+ updated, next, err = module.Notifications.List(ctx, alice.SpaceID, "", 2)
+ require.NoError(t, err)
+ require.Len(t, updated, 2)
+ require.Equal(t, posts[1], updated[0].PostID.Int64)
+ require.Equal(t, posts[2], updated[1].PostID.Int64)
+ require.Empty(t, next)
+ require.NoError(t, module.Posts.DeletePost(ctx, posts[1], alice.SpaceID))
+ remaining, next, err := module.Notifications.List(ctx, alice.SpaceID, cursor, 2)
+ require.NoError(t, err)
+ require.Len(t, remaining, 1)
+ require.Equal(t, posts[2], remaining[0].PostID.Int64)
+ require.Empty(t, next)
+}
+
+func TestNotificationsMigrationPreservesLikesAndReadState(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ up, err := os.ReadFile("migrations/149_space_notifications.up.sql")
+ require.NoError(t, err)
+ down, err := os.ReadFile("migrations/149_space_notifications.down.sql")
+ require.NoError(t, err)
+ tx, err := module.Posts.DB.BeginTx(ctx, nil)
+ require.NoError(t, err)
+ defer tx.Rollback()
+ _, err = tx.ExecContext(ctx, string(down))
+ require.NoError(t, err)
+ for index, timestamp := range []int64{1000, 3000, 5000} {
+ var postID int64
+ require.NoError(t, tx.QueryRowContext(ctx, `INSERT INTO space_posts (space_id, encrypted_post_key, is_deleted) VALUES ($1, $2, $3) RETURNING post_id`, alice.SpaceID, []byte("key"), index == 2).Scan(&postID))
+ _, err = tx.ExecContext(ctx, `INSERT INTO space_messages (message_id, sender_space_id, recipient_space_id, kind, reply_post_id, created_at) VALUES ($1, $2, $3, 'post_like', $4, $5)`, []string{"read-like", "unread-like", "deleted-post-like"}[index], bob.SpaceID, alice.SpaceID, postID, timestamp)
+ require.NoError(t, err)
+ }
+ _, err = tx.ExecContext(ctx, `UPDATE space_notification_read_markers SET read_at = 2000 WHERE viewer_space_id = $1 AND friend_space_id = $2`, alice.SpaceID, bob.SpaceID)
+ require.NoError(t, err)
+ _, err = tx.ExecContext(ctx, string(up))
+ require.NoError(t, err)
+ var readAt sql.NullInt64
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT read_at FROM space_notifications WHERE post_like_id = 'read-like'`).Scan(&readAt))
+ require.True(t, readAt.Valid)
+ require.Equal(t, int64(2000), readAt.Int64)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT read_at FROM space_notifications WHERE post_like_id = 'unread-like'`).Scan(&readAt))
+ require.False(t, readAt.Valid)
+ var count int
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_post_likes`).Scan(&count))
+ require.Equal(t, 2, count)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_messages WHERE kind = 'post_like'`).Scan(&count))
+ require.Zero(t, count)
+ _, err = tx.ExecContext(ctx, string(down))
+ require.NoError(t, err)
+ require.NoError(t, tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_messages WHERE kind = 'post_like'`).Scan(&count))
+ require.Equal(t, 2, count)
+}
diff --git a/server/space/repo/pokes.go b/server/space/repo/pokes.go
new file mode 100644
index 0000000000..73e602a0ed
--- /dev/null
+++ b/server/space/repo/pokes.go
@@ -0,0 +1,55 @@
+package repo
+
+import (
+ "context"
+ "database/sql"
+
+ "github.com/ente/museum/ente/base"
+ "github.com/ente/stacktrace"
+)
+
+type PokesRepository struct {
+ DB *sql.DB
+}
+
+func (r *PokesRepository) Create(ctx context.Context, senderSpaceID, recipientSpaceID, requestID string) (bool, error) {
+ tx, err := r.DB.BeginTx(ctx, nil)
+ if err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ defer tx.Rollback()
+ var friendSpaceID 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
+ `, recipientSpaceID, senderSpaceID).Scan(&friendSpaceID); err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ pokeID := base.MustNewID("wpk")
+ result, err := tx.ExecContext(ctx, `
+ INSERT INTO space_pokes (poke_id, sender_space_id, recipient_space_id, client_request_id)
+ VALUES ($1, $2, $3, $4)
+ ON CONFLICT (sender_space_id, recipient_space_id, client_request_id) DO NOTHING
+ `, pokeID, senderSpaceID, recipientSpaceID, requestID)
+ if err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ count, err := result.RowsAffected()
+ if err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ if count == 0 {
+ return false, nil
+ }
+ if _, err := tx.ExecContext(ctx, `
+ INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, poke_id, created_at)
+ SELECT $1, recipient_space_id, sender_space_id, 'poke', poke_id, created_at
+ FROM space_pokes WHERE poke_id = $2
+ `, base.MustNewID("wnot"), pokeID); err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ if err := tx.Commit(); err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ return true, nil
+}
diff --git a/server/space/repo/pokes_test.go b/server/space/repo/pokes_test.go
new file mode 100644
index 0000000000..272a570b84
--- /dev/null
+++ b/server/space/repo/pokes_test.go
@@ -0,0 +1,79 @@
+package repo
+
+import (
+ "sync"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestPokesCreateNotificationsOnceAndGroupReadState(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := t.Context()
+ alice, bob := notificationTestSpaces(t, module)
+ results := make(chan bool, 8)
+ failures := make(chan error, 8)
+ var workers sync.WaitGroup
+ for range 8 {
+ workers.Add(1)
+ go func() {
+ defer workers.Done()
+ created, err := module.Pokes.Create(ctx, bob.SpaceID, alice.SpaceID, "first")
+ results <- created
+ failures <- err
+ }()
+ }
+ workers.Wait()
+ close(results)
+ close(failures)
+ createdCount := 0
+ for created := range results {
+ if created {
+ createdCount++
+ }
+ }
+ for err := range failures {
+ require.NoError(t, err)
+ }
+ require.Equal(t, 1, createdCount)
+ require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_pokes`))
+ require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications WHERE kind = 'poke'`))
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_messages`))
+ unread, err := module.Read.HasUnreadNotifications(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, unread)
+ _, err = module.Pokes.Create(ctx, bob.SpaceID, alice.SpaceID, "second")
+ require.NoError(t, err)
+ page, cursor, err := module.Notifications.List(ctx, alice.SpaceID, "", 1)
+ require.NoError(t, err)
+ require.Len(t, page, 1)
+ require.Empty(t, cursor)
+ require.Equal(t, "poke", page[0].Kind)
+ require.Equal(t, bob.SpaceID, page[0].Actors[0].SpaceID)
+ require.Equal(t, int64(1), page[0].ActorCount)
+ require.True(t, page[0].Unread)
+ require.NoError(t, module.Notifications.MarkRead(ctx, bob.SpaceID, []string{page[0].NotificationID}))
+ unread, err = module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.True(t, unread)
+ _, err = module.Pokes.Create(ctx, bob.SpaceID, alice.SpaceID, "third")
+ require.NoError(t, err)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{page[0].NotificationID}))
+ require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications WHERE read_at IS NULL`))
+ page, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, []string{page[0].NotificationID}))
+ unread, err = module.Notifications.HasUnread(ctx, alice.SpaceID)
+ require.NoError(t, err)
+ require.False(t, unread)
+ _, err = module.Pokes.DB.ExecContext(ctx, `DELETE FROM space_pokes WHERE client_request_id = 'third'`)
+ require.NoError(t, err)
+ require.Equal(t, int64(2), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications`))
+ require.NoError(t, module.Friends.DeleteFriendship(ctx, alice.SpaceID, bob.SpaceID))
+ _, err = module.Pokes.Create(ctx, bob.SpaceID, alice.SpaceID, "not-friends")
+ require.Error(t, err)
+ page, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 20)
+ require.NoError(t, err)
+ require.Empty(t, page)
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notifications`))
+}
diff --git a/server/space/repo/posts.go b/server/space/repo/posts.go
index cad1e25d80..3eaa61d87d 100644
--- a/server/space/repo/posts.go
+++ b/server/space/repo/posts.go
@@ -148,10 +148,9 @@ func (r *PostsRepository) GetPost(ctx context.Context, postID int64, viewerSpace
query := postRecordSelectSQL(`
EXISTS (
SELECT 1
- FROM space_messages m
- WHERE m.kind = 'post_like'
- AND m.reply_post_id = p.post_id
- AND m.sender_space_id = $2
+ FROM space_post_likes l
+ WHERE l.post_id = p.post_id
+ AND l.actor_space_id = $2
)`) + `
FROM space_posts p
JOIN spaces w ON w.space_id = p.space_id
@@ -170,10 +169,9 @@ func (r *PostsRepository) ListPostsBySpace(ctx context.Context, spaceID string,
query := postRecordSelectSQL(`
EXISTS (
SELECT 1
- FROM space_messages m
- WHERE m.kind = 'post_like'
- AND m.reply_post_id = p.post_id
- AND m.sender_space_id = $2
+ FROM space_post_likes l
+ WHERE l.post_id = p.post_id
+ AND l.actor_space_id = $2
)`) + `
FROM space_posts p
JOIN spaces w ON w.space_id = p.space_id
@@ -211,10 +209,9 @@ func (r *PostsRepository) ListFeed(ctx context.Context, viewerSpaceID string, cu
query := postRecordSelectSQL(`
CASE WHEN p.space_id = $1 THEN FALSE ELSE EXISTS (
SELECT 1
- FROM space_messages m
- WHERE m.kind = 'post_like'
- AND m.reply_post_id = p.post_id
- AND m.sender_space_id = $1
+ FROM space_post_likes l
+ WHERE l.post_id = p.post_id
+ AND l.actor_space_id = $1
) END`) + `
FROM (
SELECT $1::TEXT AS space_id
@@ -307,6 +304,9 @@ func (r *PostsRepository) DeletePost(ctx context.Context, postID int64, spaceID
}
return nil
}
+ if _, err := tx.ExecContext(ctx, `DELETE FROM space_post_likes WHERE post_id = $1`, postID); err != nil {
+ return stacktrace.Propagate(err, "")
+ }
rows, err := tx.QueryContext(ctx, `
SELECT a.object_key, a.bucket_id, COALESCE(a.size, 1), p.space_id
FROM space_post_assets a
@@ -344,40 +344,51 @@ func (r *PostsRepository) DeletePost(ctx context.Context, postID int64, spaceID
}
func (r *PostsRepository) SetLikeWithCreated(ctx context.Context, postID int64, actorSpaceID string, like bool) (bool, error) {
- if like {
- res, err := r.DB.ExecContext(ctx, `
- INSERT INTO space_messages (
- message_id,
- sender_space_id,
- recipient_space_id,
- kind,
- reply_post_id
- )
- SELECT $3, $2, p.space_id, 'post_like', p.post_id
- FROM space_posts p
- WHERE p.post_id = $1
- AND p.space_id <> $2
- AND p.is_deleted = FALSE
- ON CONFLICT (reply_post_id, sender_space_id) WHERE kind = 'post_like' DO NOTHING
- `, postID, strings.TrimSpace(actorSpaceID), base.MustNewID("wmsg"))
+ tx, err := r.DB.BeginTx(ctx, nil)
+ if err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ defer tx.Rollback()
+ var recipientSpaceID string
+ if err := tx.QueryRowContext(ctx, `
+ SELECT space_id FROM space_posts
+ WHERE post_id = $1 AND space_id <> $2 AND is_deleted = FALSE
+ FOR UPDATE
+ `, postID, actorSpaceID).Scan(&recipientSpaceID); err != nil {
+ return false, stacktrace.Propagate(err, "")
+ }
+ if !like {
+ result, err := tx.ExecContext(ctx, `DELETE FROM space_post_likes WHERE post_id = $1 AND actor_space_id = $2`, postID, actorSpaceID)
if err != nil {
return false, stacktrace.Propagate(err, "")
}
- affected, err := res.RowsAffected()
+ changed, err := result.RowsAffected()
if err != nil {
return false, stacktrace.Propagate(err, "")
}
- return affected > 0, nil
+ return changed > 0, stacktrace.Propagate(tx.Commit(), "")
+ }
+ likeID := base.MustNewID("wlike")
+ var createdAt int64
+ err = tx.QueryRowContext(ctx, `
+ INSERT INTO space_post_likes (like_id, post_id, actor_space_id)
+ VALUES ($1, $2, $3)
+ ON CONFLICT (post_id, actor_space_id) DO NOTHING
+ RETURNING created_at
+ `, likeID, postID, actorSpaceID).Scan(&createdAt)
+ if err == sql.ErrNoRows {
+ return false, stacktrace.Propagate(tx.Commit(), "")
}
- res, err := r.DB.ExecContext(ctx, `DELETE FROM space_messages WHERE kind = 'post_like' AND reply_post_id = $1 AND sender_space_id = $2`, postID, strings.TrimSpace(actorSpaceID))
if err != nil {
return false, stacktrace.Propagate(err, "")
}
- affected, err := res.RowsAffected()
- if err != nil {
+ if _, err := tx.ExecContext(ctx, `
+ INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, post_like_id, created_at)
+ VALUES ($1, $2, $3, 'post_like', $4, $5)
+ `, base.MustNewID("wnot"), recipientSpaceID, actorSpaceID, likeID, createdAt); err != nil {
return false, stacktrace.Propagate(err, "")
}
- return affected > 0, nil
+ return true, stacktrace.Propagate(tx.Commit(), "")
}
func (r *PostsRepository) UpdateCaption(ctx context.Context, postID int64, spaceID string, captionCipher []byte) error {
diff --git a/server/space/repo/read_markers.go b/server/space/repo/read_markers.go
index 39ec4ddad6..195840e975 100644
--- a/server/space/repo/read_markers.go
+++ b/server/space/repo/read_markers.go
@@ -66,13 +66,6 @@ func (r *ReadMarkersRepository) HasUnreadNotifications(ctx context.Context, view
AND nrm.friend_space_id = activity.friend_space_id
WHERE activity.notification_created_at > COALESCE(nrm.read_at, 0)
LIMIT 1
- ) OR EXISTS (
- SELECT 1
- FROM space_friend_requests fr
- JOIN spaces requester_space ON requester_space.space_id = fr.requester_space_id
- JOIN users requester_owner ON requester_owner.user_id = requester_space.owner_id AND requester_owner.encrypted_email IS NOT NULL
- WHERE fr.target_space_id = $1
- LIMIT 1
)
`, strings.TrimSpace(viewerSpaceID)).Scan(&exists); err != nil {
return false, stacktrace.Propagate(err, "")
diff --git a/web/apps/space/public/_redirects b/web/apps/space/public/_redirects
index b660281a1d..1076831251 100644
--- a/web/apps/space/public/_redirects
+++ b/web/apps/space/public/_redirects
@@ -3,6 +3,7 @@
/app/friends /app/friends 200
/app/messages /app/messages 200
/app/messages/* /app/messages/[spaceId] 200
+/app/notifications /app/notifications 200
/app/posts/* /app/posts/[spaceId]/[postId] 200
/app/profile /app/profile 200
/app/profile/cover /app/profile/cover 200
diff --git a/web/apps/space/src/components/ActionToast.tsx b/web/apps/space/src/components/ActionToast.tsx
index 8fa88d0348..c2e34ea610 100644
--- a/web/apps/space/src/components/ActionToast.tsx
+++ b/web/apps/space/src/components/ActionToast.tsx
@@ -63,7 +63,7 @@ export const SpaceActionToast: React.FC<SpaceActionToastProps> = ({
px: toastHorizontalPadding,
pointerEvents: "none",
position: "fixed",
- top: "calc(env(safe-area-inset-top) + 12px)",
+ top: "calc(env(safe-area-inset-top) + 8px)",
transform: "translateX(-50%)",
width: "100%",
zIndex,
@@ -79,7 +79,7 @@ export const SpaceActionToast: React.FC<SpaceActionToastProps> = ({
sx={{
alignItems: "center",
bgcolor: spaceHomeSurface,
- borderRadius: "24px",
+ borderRadius: "32px",
boxShadow: "0 12px 32px rgba(0, 0, 0, 0.18)",
boxSizing: "border-box",
color: textBase,
diff --git a/web/apps/space/src/components/ActivityList.tsx b/web/apps/space/src/components/ActivityList.tsx
new file mode 100644
index 0000000000..8e11e3cf85
--- /dev/null
+++ b/web/apps/space/src/components/ActivityList.tsx
@@ -0,0 +1,122 @@
+import { Box } from "@mui/material";
+import { SpaceAvatarImage } from "components/AvatarImage";
+import { formatTimeAgo } from "ente-base/date";
+import { useDecodedImage } from "hooks/use-decoded-image";
+import type { ReactNode } from "react";
+import { spaceTextMuted } from "styles/colors";
+
+export const SpaceActivityAvatar = ({
+ avatarUrl,
+ loading = false,
+ size,
+}: {
+ avatarUrl?: string | null;
+ loading?: boolean;
+ size: number;
+}) => {
+ const image = useDecodedImage(avatarUrl);
+ return (
+ <Box
+ sx={{
+ alignItems: "center",
+ borderRadius: "50%",
+ display: "flex",
+ flexShrink: 0,
+ height: size,
+ justifyContent: "center",
+ overflow: "hidden",
+ width: size,
+ }}
+ >
+ {!loading && image.ready && (
+ <SpaceAvatarImage src={image.failed ? null : image.src} />
+ )}
+ </Box>
+ );
+};
+
+export const SpaceActivityIdentity = ({
+ name,
+ createdAtMs,
+}: {
+ name: ReactNode;
+ createdAtMs: number;
+}) => (
+ <Box
+ sx={{ alignItems: "center", display: "flex", gap: "4px", minWidth: 0 }}
+ >
+ <Box
+ sx={{
+ flex: "0 1 auto",
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 14,
+ fontWeight: 700,
+ lineHeight: "20px",
+ minWidth: 0,
+ overflow: "hidden",
+ textOverflow: "ellipsis",
+ whiteSpace: "nowrap",
+ }}
+ >
+ {name}
+ </Box>
+ <Box
+ aria-hidden
+ component="span"
+ sx={{
+ color: spaceTextMuted,
+ flexShrink: 0,
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 12,
+ fontWeight: 600,
+ lineHeight: "16px",
+ }}
+ >
+ &middot;
+ </Box>
+ <Box
+ component="time"
+ dateTime={new Date(createdAtMs).toISOString()}
+ sx={{
+ color: spaceTextMuted,
+ flexShrink: 0,
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 12,
+ fontWeight: 600,
+ lineHeight: "16px",
+ whiteSpace: "nowrap",
+ }}
+ >
+ {formatTimeAgo(createdAtMs * 1000)}
+ </Box>
+ </Box>
+);
+
+export const SpaceActivitySection = ({
+ title,
+ children,
+}: {
+ title: string;
+ children: ReactNode;
+}) => (
+ <Box component="section" sx={{ mb: "10px" }}>
+ <Box
+ component="h2"
+ sx={{
+ color: spaceTextMuted,
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 13,
+ fontWeight: 700,
+ lineHeight: "18px",
+ m: 0,
+ pb: "4px",
+ pt: "12px",
+ }}
+ >
+ {title}
+ </Box>
+ <Box component="ul" sx={{ listStyle: "none", m: 0, p: 0 }}>
+ {children}
+ </Box>
+ </Box>
+);
diff --git a/web/apps/space/src/components/AppNavigation.tsx b/web/apps/space/src/components/AppNavigation.tsx
new file mode 100644
index 0000000000..3d2412fecb
--- /dev/null
+++ b/web/apps/space/src/components/AppNavigation.tsx
@@ -0,0 +1,290 @@
+import {
+ BubbleChatIcon,
+ Home01Icon,
+ PlusSignSquareIcon,
+ UserCircleIcon,
+ UserMultiple02Icon,
+} from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
+import { Box } from "@mui/material";
+import { SpacePostPhotoInput } from "components/PostPhotoInput";
+import log from "ente-base/log";
+import React from "react";
+import { loadCurrentUnreadStatus } from "services/space";
+import { useSpaceAppState } from "state/app-state";
+import {
+ emptySpaceUnreadStatus,
+ SpaceUnreadStatusContext,
+} from "state/navigation";
+import {
+ spaceAppBackgroundColor,
+ spaceText,
+ spaceTextMuted,
+} from "styles/colors";
+import {
+ spaceNavigationDestination,
+ spaceUnreadStatusChangedEvent,
+} from "utils/navigation";
+import { useSpaceRouter } from "utils/route-transitions";
+import { spaceRoutes } from "utils/routes";
+
+export const SpaceAppLayout = ({ children }: { children: React.ReactNode }) => {
+ const router = useSpaceRouter();
+ const {
+ pendingPostPhotoFiles,
+ profile,
+ profileLoadStatus,
+ setPendingPostPhotoFiles,
+ } = useSpaceAppState();
+ const showNavigation = Boolean(
+ router.pathname == spaceRoutes.home ||
+ router.pathname.startsWith(`${spaceRoutes.home}/`) ||
+ (profile && router.pathname == spaceRoutes.friendPage),
+ );
+ const spaceID =
+ showNavigation && profileLoadStatus == "ready"
+ ? profile?.spaceId
+ : undefined;
+ const [unreadStatus, setUnreadStatus] = React.useState(
+ emptySpaceUnreadStatus,
+ );
+ const layoutRef = React.useRef<HTMLDivElement>(null);
+ const postInputRef = React.useRef<HTMLInputElement>(null);
+ const path = router.asPath.split(/[?#]/)[0] ?? router.pathname;
+
+ React.useEffect(() => {
+ if (!spaceID) {
+ setUnreadStatus(emptySpaceUnreadStatus);
+ return;
+ }
+ let cancelled = false;
+ let sequence = 0;
+ const refresh = () => {
+ if (document.visibilityState == "hidden") return;
+ const request = ++sequence;
+ void loadCurrentUnreadStatus(spaceID)
+ .then((status) => {
+ if (!cancelled && request == sequence)
+ setUnreadStatus(status);
+ })
+ .catch((error: unknown) =>
+ log.warn("Failed to load unread status", error),
+ );
+ };
+ refresh();
+ window.addEventListener("focus", refresh);
+ window.addEventListener(spaceUnreadStatusChangedEvent, refresh);
+ document.addEventListener("visibilitychange", refresh);
+ return () => {
+ cancelled = true;
+ window.removeEventListener("focus", refresh);
+ window.removeEventListener(spaceUnreadStatusChangedEvent, refresh);
+ document.removeEventListener("visibilitychange", refresh);
+ };
+ }, [spaceID, path]);
+
+ React.useEffect(() => {
+ if (!showNavigation) return;
+ const viewport = window.visualViewport;
+ if (!viewport) return;
+ const updateViewport = () => {
+ layoutRef.current?.style.setProperty(
+ "--space-viewport-height",
+ `${viewport.height}px`,
+ );
+ layoutRef.current?.style.setProperty(
+ "--space-keyboard-inset",
+ `${Math.max(0, window.innerHeight - viewport.height - viewport.offsetTop)}px`,
+ );
+ };
+ updateViewport();
+ viewport.addEventListener("resize", updateViewport);
+ viewport.addEventListener("scroll", updateViewport);
+ return () => {
+ viewport.removeEventListener("resize", updateViewport);
+ viewport.removeEventListener("scroll", updateViewport);
+ };
+ }, [showNavigation]);
+
+ const destinations = [
+ { label: "Home", href: spaceRoutes.home, icon: Home01Icon, size: 25 },
+ {
+ label: "Messages",
+ href: spaceRoutes.messages,
+ icon: BubbleChatIcon,
+ size: 25,
+ },
+ { label: "Post", icon: PlusSignSquareIcon, href: undefined, size: 25 },
+ {
+ label: "Friends",
+ href: spaceRoutes.friends,
+ icon: UserMultiple02Icon,
+ size: 23,
+ },
+ {
+ label: "Profile",
+ href: spaceRoutes.profile,
+ icon: UserCircleIcon,
+ size: 24,
+ },
+ ];
+
+ return (
+ <SpaceUnreadStatusContext.Provider value={unreadStatus}>
+ <Box
+ ref={layoutRef}
+ className={showNavigation ? "space-app-layout" : undefined}
+ >
+ {children}
+ {showNavigation && (
+ <>
+ <SpacePostPhotoInput
+ inputRef={postInputRef}
+ onSelect={setPendingPostPhotoFiles}
+ />
+ <Box
+ component="nav"
+ aria-label="Main navigation"
+ sx={{
+ alignItems: "center",
+ bgcolor: spaceAppBackgroundColor,
+ bottom: "var(--space-keyboard-inset, 0px)",
+ display: "flex",
+ justifyContent: "space-between",
+ height: "calc(60px + env(safe-area-inset-bottom))",
+ pb: "env(safe-area-inset-bottom)",
+ left: "50%",
+ maxWidth: 390,
+ px: "10px",
+ position: "fixed",
+ transform: "translateX(-50%)",
+ viewTransitionName: "space-bottom-nav",
+ width: "100%",
+ zIndex: 20,
+ }}
+ >
+ {destinations.map(({ label, href, icon, size }) => {
+ const selected = Boolean(
+ href &&
+ href ==
+ spaceNavigationDestination(
+ router.pathname,
+ ),
+ );
+ const isPost = label == "Post";
+ return (
+ <Box
+ key={label}
+ component={isPost ? "button" : "a"}
+ href={href}
+ type={isPost ? "button" : undefined}
+ disabled={
+ isPost
+ ? Boolean(pendingPostPhotoFiles)
+ : undefined
+ }
+ aria-label={
+ label == "Messages" &&
+ unreadStatus.messagesUnread
+ ? "Messages with unread activity"
+ : label
+ }
+ aria-current={
+ selected ? "page" : undefined
+ }
+ onClick={(
+ event: React.MouseEvent<HTMLElement>,
+ ) => {
+ if (isPost) {
+ postInputRef.current?.click();
+ } else if (
+ href &&
+ !event.metaKey &&
+ !event.ctrlKey &&
+ !event.shiftKey &&
+ !event.altKey
+ ) {
+ event.preventDefault();
+ if (path == href)
+ window.scrollTo({
+ top: 0,
+ behavior: "smooth",
+ });
+ else void router.push(href);
+ }
+ }}
+ sx={{
+ alignItems: "center",
+ bgcolor: "transparent",
+ border: 0,
+ borderRadius: "24px",
+ color: selected
+ ? spaceText
+ : spaceTextMuted,
+ cursor: "pointer",
+ display: "flex",
+ height: 52,
+ justifyContent: "center",
+ minWidth: 0,
+ width: 44,
+ p: 0,
+ textDecoration: "none",
+ "&:focus-visible": {
+ outline: "2px solid #08C225",
+ outlineOffset: 2,
+ },
+ "&:disabled": {
+ opacity: 0.6,
+ cursor: "default",
+ },
+ }}
+ >
+ <Box
+ sx={{
+ alignItems: "center",
+ display: "flex",
+ height: size,
+ justifyContent: "center",
+ position: "relative",
+ width: size,
+ "& svg path:last-of-type":
+ label == "Messages"
+ ? { display: "none" }
+ : undefined,
+ }}
+ >
+ <HugeiconsIcon
+ icon={icon}
+ size={size}
+ strokeWidth={
+ selected ? 2.2 : 1.8
+ }
+ />
+ {label == "Messages" &&
+ unreadStatus.messagesUnread && (
+ <Box
+ aria-hidden
+ sx={{
+ bgcolor: "#F63A3A",
+ border: `2px solid ${spaceAppBackgroundColor}`,
+ borderRadius: "50%",
+ height: 11,
+ position:
+ "absolute",
+ right: 0,
+ top: 0,
+ width: 11,
+ }}
+ />
+ )}
+ </Box>
+ </Box>
+ );
+ })}
+ </Box>
+ </>
+ )}
+ </Box>
+ </SpaceUnreadStatusContext.Provider>
+ );
+};
diff --git a/web/apps/space/src/components/AuthenticatedFriendProfile.tsx b/web/apps/space/src/components/AuthenticatedFriendProfile.tsx
index 862817cc53..f01ddc0f6d 100644
--- a/web/apps/space/src/components/AuthenticatedFriendProfile.tsx
+++ b/web/apps/space/src/components/AuthenticatedFriendProfile.tsx
@@ -15,6 +15,7 @@ import {
loadCurrentSpaceProfilePostsPage,
removeCurrentSpaceFriend,
replyToCurrentPost,
+ sendCurrentPoke,
setCurrentPostLiked,
type SpaceProfilePost,
} from "services/space";
@@ -169,6 +170,9 @@ export const AuthenticatedFriendProfile: React.FC<
onMessageFriend={() =>
void router.push(spaceRoutes.message(friendSpaceId))
}
+ onPokeFriend={(requestID) =>
+ sendCurrentPoke(actorSpaceId, friendSpaceId, requestID)
+ }
onOpenProfileCover={() => setOpenProfileImage("cover")}
onOpenProfilePhoto={() => setOpenProfileImage("avatar")}
onReplyToPost={(postSpaceId, postId, text, objectKey) =>
diff --git a/web/apps/space/src/components/FileViewer.tsx b/web/apps/space/src/components/FileViewer.tsx
index 696c494525..e8148dfbf9 100644
--- a/web/apps/space/src/components/FileViewer.tsx
+++ b/web/apps/space/src/components/FileViewer.tsx
@@ -160,8 +160,7 @@ interface SpaceFileViewerProps {
onEditDraftPhoto?: () => void;
onDeletePost?: () => Promise<void> | void;
onDraftPostExitAnimationStart?: () => void;
- onDraftPostExitStart?: () => void;
- onDraftPostPublished?: () => void;
+ onDraftPostExitStart?: () => Promise<void>;
onAddFriendForPostAction?: (intent: SpaceInviteIntent) => void;
onOpenProfile?: () => void;
onPublishDraftPost?: (caption: string) => Promise<void>;
@@ -376,8 +375,6 @@ const SpaceViewerPhotoOverlay: React.FC<{
bgcolor: "rgba(32, 32, 32, 0.85)",
borderRadius: "16px",
boxSizing: "border-box",
- fontWeight: 400,
- lineHeight: "22px",
maxHeight: "33svh",
overflowWrap: "anywhere",
overflowY: "auto",
@@ -412,7 +409,6 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
onDeletePost,
onDraftPostExitAnimationStart,
onDraftPostExitStart,
- onDraftPostPublished,
onAddFriendForPostAction,
onOpenProfile,
onPublishDraftPost,
@@ -824,10 +820,16 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
return;
}
setDraftPostExitPhase("waiting-for-keyboard");
- onDraftPostExitStart?.();
+ const exitReady = onDraftPostExitStart?.();
dismissCaptionKeyboard(() => {
- setDraftPostExitPhase("animating");
- onDraftPostExitAnimationStart?.();
+ void Promise.resolve(exitReady)
+ .catch((error: unknown) => {
+ log.error("Failed to open the home feed", error);
+ })
+ .then(() => {
+ setDraftPostExitPhase("animating");
+ onDraftPostExitAnimationStart?.();
+ });
});
void publication.catch((error: unknown) => {
log.error("Failed to publish space post", error);
@@ -1109,16 +1111,11 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
onClose();
}, [isDeleteExit, onClose]);
- const finishDraftPostExit = React.useCallback(() => {
- onClose();
- onDraftPostPublished?.();
- }, [onClose, onDraftPostPublished]);
-
React.useEffect(() => {
if (!isDraftPostExitAnimating) return;
if (window.matchMedia("(prefers-reduced-motion: reduce)").matches)
- finishDraftPostExit();
- }, [finishDraftPostExit, isDraftPostExitAnimating]);
+ onClose();
+ }, [onClose, isDraftPostExitAnimating]);
React.useEffect(() => {
const root = viewerRootRef.current;
@@ -1412,7 +1409,7 @@ export const SpaceFileViewer: React.FC<SpaceFileViewerProps> = ({
)
return;
- finishDraftPostExit();
+ onClose();
}}
sx={{
bgcolor: "rgb(0 0 0 / var(--space-viewer-bg-opacity, 1))",
diff --git a/web/apps/space/src/components/HomeHeader.tsx b/web/apps/space/src/components/HomeHeader.tsx
index c804999fcc..2e43a19ff9 100644
--- a/web/apps/space/src/components/HomeHeader.tsx
+++ b/web/apps/space/src/components/HomeHeader.tsx
@@ -1,296 +1,141 @@
-import { BubbleChatIcon } from "@hugeicons/core-free-icons";
+import { Menu01Icon, Notification01Icon } from "@hugeicons/core-free-icons";
import { HugeiconsIcon } from "@hugeicons/react";
-import { alpha, Box, Skeleton } from "@mui/material";
-import { SpaceAvatarImage } from "components/AvatarImage";
+import { Box } from "@mui/material";
import React from "react";
-import type { SetupProfile } from "screens/SetupProfileScreen";
-import { useSpaceAppState } from "state/app-state";
-import {
- spaceAppBackgroundColor,
- spaceHomeSurface,
- spaceSurface,
- spaceText,
-} from "styles/colors";
-import { spaceTouchTargetSize } from "styles/touch-targets";
+import { useSpaceUnreadStatus } from "state/navigation";
+import { spaceAppBackgroundColor, spaceText } from "styles/colors";
+import { useSpaceRouter } from "utils/route-transitions";
+import { spaceRoutes } from "utils/routes";
-const green = "#08C225";
-const dangerColor = "#F63A3A";
-const headerActionSize = spaceTouchTargetSize;
-const headerAvatarImageSize = 28;
-const headerChatCircleSize = 36;
-const headerIconSize = 25;
-const headerSideWidth = 36;
-const avatarFadeSx = {
- "@keyframes spaceAvatarFade": { from: { opacity: 0 }, to: { opacity: 1 } },
- animation: "spaceAvatarFade 320ms cubic-bezier(0.22, 1, 0.36, 1) both",
- "@media (prefers-reduced-motion: reduce)": { animation: "none" },
-} as const;
+export const SpaceHomeHeader: React.FC = () => {
+ const router = useSpaceRouter();
+ const { notificationsUnread } = useSpaceUnreadStatus();
+ const [visible, setVisible] = React.useState(true);
-const spaceHomeHeaderHeight = 68;
-const spaceHomeHeaderBarHeight = 44;
-
-interface SpaceHomeHeaderProps {
- children?: React.ReactNode;
- logoActions?: React.ReactNode;
- onOpenMessages?: () => void;
- onOpenProfile?: () => void;
- profile: SetupProfile | null;
- showUnreadIndicator?: boolean;
-}
+ React.useEffect(() => {
+ let previousY = window.scrollY;
+ let frame = 0;
+ const update = () => {
+ frame = 0;
+ const y = Math.max(0, window.scrollY);
+ if (y <= 60) {
+ setVisible(true);
+ previousY = y;
+ } else if (Math.abs(y - previousY) >= 8) {
+ setVisible(y < previousY);
+ previousY = y;
+ }
+ };
+ const onScroll = () => {
+ if (!frame) frame = window.requestAnimationFrame(update);
+ };
+ window.addEventListener("scroll", onScroll, { passive: true });
+ return () => {
+ window.removeEventListener("scroll", onScroll);
+ window.cancelAnimationFrame(frame);
+ };
+ }, []);
+ const actionSx = {
+ alignItems: "center",
+ bgcolor: "transparent",
+ border: 0,
+ borderRadius: "50%",
+ color: spaceText,
+ cursor: "pointer",
+ display: "flex",
+ height: 44,
+ p: 0,
+ position: "relative",
+ width: 44,
+ "&:focus-visible": { outline: "2px solid #08C225", outlineOffset: 2 },
+ } as const;
-export const SpaceHomeHeader: React.FC<SpaceHomeHeaderProps> = ({
- children,
- logoActions,
- onOpenMessages,
- onOpenProfile,
- profile,
- showUnreadIndicator = false,
-}) => (
- <Box
- component="header"
- sx={{
- alignItems: "center",
- background: "transparent",
- boxSizing: "border-box",
- color: spaceText,
- display: "grid",
- gap: "12px",
- gridTemplateColumns: `${headerSideWidth}px minmax(0, 1fr) ${headerSideWidth}px`,
- height: spaceHomeHeaderHeight,
- maxWidth: "100%",
- pb: "12px",
- position: "relative",
- pt: "12px",
- px: "8px",
- width: "100%",
- zIndex: 4,
- "&::after": {
- bgcolor: spaceHomeSurface,
- borderRadius: "24px",
- content: '""',
- height: spaceHomeHeaderBarHeight,
- left: "8px",
- pointerEvents: "none",
- position: "absolute",
- right: "8px",
- top: "12px",
- zIndex: 0,
- },
- "&::before": {
- WebkitBackdropFilter: "blur(4px)",
- WebkitMaskImage:
- "linear-gradient(to bottom, #000 0%, transparent 100%)",
- backdropFilter: "blur(4px)",
- background: `linear-gradient(to bottom, ${spaceAppBackgroundColor}, ${alpha(spaceAppBackgroundColor, 0.35)} 75%, transparent)`,
- content: '""',
- height: "calc(100% + 28px)",
- left: 0,
- maskImage:
- "linear-gradient(to bottom, #000 0%, transparent 100%)",
- pointerEvents: "none",
- position: "absolute",
- right: 0,
- top: 0,
- zIndex: -1,
- },
- "@media (min-width: 600px)": { maxWidth: 390 },
- }}
- >
- {children}
+ return (
<Box
- component="button"
- type="button"
- aria-label="Open profile"
- onClick={onOpenProfile}
+ component="header"
sx={{
- appearance: "none",
alignItems: "center",
- bgcolor: "transparent",
- border: 0,
- borderRadius: "50%",
- boxSizing: "border-box",
+ bgcolor: spaceAppBackgroundColor,
color: spaceText,
- cursor: onOpenProfile ? "pointer" : "default",
- display: "flex",
- height: headerActionSize,
- justifyContent: "center",
- lineHeight: 0,
- overflow: "hidden",
- p: 0,
- placeSelf: "center start",
- position: "relative",
- width: headerActionSize,
- zIndex: 1,
- "&:focus-visible": {
- outline: `2px solid ${green}`,
- outlineOffset: 2,
+ display: "grid",
+ gridTemplateColumns: "44px minmax(0, 1fr) 44px",
+ height: 60,
+ mx: "auto",
+ px: 2,
+ position: "sticky",
+ top: 0,
+ transform: visible ? "translateY(0)" : "translateY(-100%)",
+ transition: "transform 220ms cubic-bezier(0.2, 0, 0, 1)",
+ width: "100%",
+ zIndex: 10,
+ "@media (prefers-reduced-motion: reduce)": {
+ transition: "none",
},
+ "@media (min-width: 600px)": { maxWidth: 390 },
}}
>
- <SpaceHomeHeaderAvatar profile={profile} />
- </Box>
- <Box
- sx={{
- alignItems: "center",
- alignSelf: "center",
- boxSizing: "border-box",
- display: "flex",
- height: 36,
- justifyContent: "center",
- justifySelf: "center",
- lineHeight: 0,
- minWidth: 0,
- overflow: "visible",
- placeSelf: "center",
- position: "relative",
- px: "16px",
- zIndex: 1,
- }}
- >
- <Box sx={{ position: "relative" }}>
- <Box
- component="img"
- alt="Space"
- src="/images/space.svg"
- sx={{ display: "block", height: 19, width: "auto" }}
- />
- {logoActions && (
- <Box
- sx={{
- left: "calc(100% + 4px)",
- position: "absolute",
- top: "50%",
- transform: "translateY(-50%)",
- }}
- >
- {logoActions}
- </Box>
- )}
+ <Box
+ component="button"
+ type="button"
+ aria-label="Settings"
+ onClick={() => void router.push(spaceRoutes.settings)}
+ sx={{ ...actionSx, justifyContent: "flex-start" }}
+ >
+ <HugeiconsIcon icon={Menu01Icon} size={22} strokeWidth={2.4} />
</Box>
- </Box>
- <Box
- component="button"
- type="button"
- aria-label={
- showUnreadIndicator
- ? "Open messages with unread activity"
- : "Open messages"
- }
- onClick={onOpenMessages}
- sx={{
- appearance: "none",
- alignItems: "center",
- bgcolor: "transparent",
- border: 0,
- boxSizing: "border-box",
- color: spaceText,
- cursor: onOpenMessages ? "pointer" : "default",
- display: "flex",
- fontSize: 0,
- height: headerActionSize,
- justifyContent: "center",
- justifySelf: "end",
- lineHeight: 0,
- p: 0,
- position: "relative",
- width: headerActionSize,
- zIndex: 1,
- "& svg": { display: "block" },
- "&:focus-visible": {
- borderRadius: "50%",
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- }}
- >
<Box
- aria-hidden
+ component="img"
+ alt="Space"
+ src="/images/space.svg"
sx={{
- alignItems: "center",
- display: "flex",
- height: headerChatCircleSize,
- justifyContent: "center",
- position: "relative",
- width: headerChatCircleSize,
- "& svg path:last-of-type": { display: "none" },
+ display: "block",
+ height: 20,
+ justifySelf: "center",
+ width: "auto",
}}
+ />
+ <Box
+ component="button"
+ type="button"
+ aria-label={
+ notificationsUnread
+ ? "Notifications with unread activity"
+ : "Notifications"
+ }
+ onClick={() => void router.push(spaceRoutes.notifications)}
+ sx={{ ...actionSx, justifyContent: "flex-end" }}
>
- <HugeiconsIcon
- icon={BubbleChatIcon}
- size={headerIconSize}
- strokeWidth={2.2}
- />
- {showUnreadIndicator && (
- <Box
- sx={{
- "@keyframes spaceUnreadBadgePing": {
- "75%, 100%": {
- opacity: 0,
- transform: "scale(2.5)",
- },
- },
- "@media (prefers-reduced-motion: reduce)": {
- "&::after": { display: "none" },
- },
- bgcolor: dangerColor,
- border: `2px solid ${spaceHomeSurface}`,
- borderRadius: "50%",
- boxSizing: "border-box",
- height: 12.5,
- position: "absolute",
- right: 4.5,
- top: 5,
- width: 12.5,
- zIndex: 1,
- "&::after": {
- animation:
- "spaceUnreadBadgePing 1.25s cubic-bezier(0, 0, 0.2, 1) 1 forwards",
- bgcolor: dangerColor,
+ <Box
+ component="span"
+ sx={{
+ display: "flex",
+ height: 25,
+ position: "relative",
+ width: 25,
+ }}
+ >
+ <HugeiconsIcon
+ icon={Notification01Icon}
+ size={25}
+ strokeWidth={1.8}
+ />
+ {notificationsUnread && (
+ <Box
+ aria-hidden
+ sx={{
+ bgcolor: "#F63A3A",
+ border: `2px solid ${spaceAppBackgroundColor}`,
borderRadius: "50%",
- content: '""',
- inset: 0,
- opacity: 0.75,
- pointerEvents: "none",
+ height: 11,
position: "absolute",
- zIndex: -1,
- },
- }}
- />
- )}
+ right: 0,
+ top: 0,
+ width: 11,
+ }}
+ />
+ )}
+ </Box>
</Box>
</Box>
- </Box>
-);
-
-const SpaceHomeHeaderAvatar: React.FC<{ profile: SetupProfile | null }> = ({
- profile,
-}) => {
- const { cachedProfileAvatarUrl } = useSpaceAppState();
- const avatarUrl = profile ? profile.avatarUrl : cachedProfileAvatarUrl;
-
- return avatarUrl || (profile && !profile.avatarObjectID) ? (
- <Box
- key={avatarUrl ?? "default-avatar"}
- sx={{
- ...avatarFadeSx,
- borderRadius: "50%",
- filter: avatarUrl ? undefined : "brightness(0.9)",
- height: headerAvatarImageSize,
- overflow: "hidden",
- width: headerAvatarImageSize,
- }}
- >
- <SpaceAvatarImage src={avatarUrl} />
- </Box>
- ) : (
- <Skeleton
- variant="circular"
- sx={{
- bgcolor: spaceSurface,
- height: headerAvatarImageSize,
- transform: "none",
- width: headerAvatarImageSize,
- }}
- />
);
};
diff --git a/web/apps/space/src/components/MessagesPage.tsx b/web/apps/space/src/components/MessagesPage.tsx
index 8d96a40b75..1a5cc48b0c 100644
--- a/web/apps/space/src/components/MessagesPage.tsx
+++ b/web/apps/space/src/components/MessagesPage.tsx
@@ -1,4 +1,3 @@
-import { SpaceFriendRequestCanceledToast } from "components/FriendRequestCanceledToast";
import { SpacePageMeta } from "components/PageMeta";
import { SpaceRouteFallback } from "components/RouteFallback";
import log from "ente-base/log";
@@ -7,18 +6,15 @@ import { MessagesScreen } from "screens/MessagesScreen";
import type { SetupProfile } from "screens/SetupProfileScreen";
import { spaceInviteURL } from "services/invite";
import {
- confirmCurrentFriendRequest,
- deleteCurrentFriendRequest,
deleteCurrentMessage,
- loadCurrentMessageActivityPostPreview,
- loadCurrentMessageConversationAvatar,
+ loadCurrentFriendAvatarURL,
loadCurrentMessageConversations,
loadCurrentMessageThread,
+ loadCurrentPostPreview,
loadCurrentSpaceProfile,
markCurrentMessagesRead,
replyToCurrentMessage,
sendCurrentMessage,
- sendCurrentPoke,
setCurrentMessageReaction,
shouldAutoReadMessageActivities,
type SpaceMessage,
@@ -26,7 +22,6 @@ import {
} from "services/space";
import { useSpaceAppState } from "state/app-state";
import { spaceAppBackgroundColor } from "styles/colors";
-import { isFriendRequestCanceledError } from "utils/friend-errors";
import { useSpaceRouter } from "utils/route-transitions";
import { spaceRoutes } from "utils/routes";
@@ -38,16 +33,7 @@ const friendSpaceId = (friend: SpaceMessageConversation["friend"]) =>
friend.spaceId ?? friend.id;
const conversationId = (conversation: SpaceMessageConversation) =>
- conversation.latestActivity.type == "friend_request"
- ? conversation.latestActivity.id
- : friendSpaceId(conversation.friend);
-
-const friendRequestIdFromConversation = (
- conversation: SpaceMessageConversation,
-) => Number(conversation.latestActivity.id.split(":")[1]);
-
-const isFriendRequestConversation = (conversation: SpaceMessageConversation) =>
- conversation.latestActivity.type == "friend_request";
+ friendSpaceId(conversation.friend);
let nextLocalMessageID = 0;
@@ -121,19 +107,13 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
profileLoadError,
profileLoadStatus,
setFriends,
- setPendingPostPhotoFiles,
} = useSpaceAppState();
const [conversations, setConversations] = React.useState<
SpaceMessageConversation[]
>([]);
- const [latestPostCreatedAtMs, setLatestPostCreatedAtMs] = React.useState<
- number | null
- >();
const [isConversationsLoading, setIsConversationsLoading] =
React.useState(true);
const [isThreadLoading, setIsThreadLoading] = React.useState(false);
- const [showFriendRequestCanceledToast, setShowFriendRequestCanceledToast] =
- React.useState(false);
const [messages, setMessages] = React.useState<SpaceMessage[]>([]);
const reactionQueues = React.useRef(new Map<string, Promise<void>>());
const savedReactions = React.useRef(new Map<string, string | undefined>());
@@ -145,9 +125,6 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
selectedFriendProfileLoadFailedSpaceId,
setSelectedFriendProfileLoadFailedSpaceId,
] = React.useState<string>();
- const [newConversationIds, setNewConversationIds] = React.useState<
- string[]
- >([]);
const selectedFriendSpaceIdRef = React.useRef<string | undefined>(
undefined,
);
@@ -167,13 +144,7 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
[conversations, selectedSpaceId],
);
const conversationFriends = React.useMemo(
- () =>
- conversations
- .filter(
- (conversation) =>
- !isFriendRequestConversation(conversation),
- )
- .map((conversation) => conversation.friend),
+ () => conversations.map((conversation) => conversation.friend),
[conversations],
);
const selectedFriendFromFriends = React.useMemo(
@@ -233,9 +204,6 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
const actorSpaceId = profile?.spaceId;
if (!actorSpaceId) return;
- setNewConversationIds((currentIds) =>
- currentIds.filter((id) => id != spaceId),
- );
setConversations((currentConversations) => {
return currentConversations.map((conversation) =>
conversationId(conversation) == spaceId
@@ -263,7 +231,6 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
const generation = ++conversationsLoadGenerationRef.current;
setIsConversationsLoading(true);
- setLatestPostCreatedAtMs(undefined);
try {
const page = await loadCurrentMessageConversations(actorSpaceId);
if (conversationsLoadGenerationRef.current != generation) {
@@ -275,9 +242,6 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
if (createdAtDiff != 0) return createdAtDiff;
return b.latestActivity.id.localeCompare(a.latestActivity.id);
});
- const unreadConversationIds = items
- .filter((conversation) => conversation.notificationUnread)
- .map(conversationId);
const passiveUnreadConversationIds = items
.filter((conversation) =>
shouldAutoReadMessageActivities(
@@ -285,21 +249,11 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
),
)
.map(conversationId);
- setNewConversationIds(unreadConversationIds);
setConversations(items);
- setLatestPostCreatedAtMs(page.latestPostCreatedAtMs);
- setFriends(
- items
- .filter(
- (conversation) =>
- !isFriendRequestConversation(conversation),
- )
- .map((conversation) => conversation.friend),
- );
+ setFriends(items.map((conversation) => conversation.friend));
for (const conversation of items) {
const friend = conversation.friend;
if (
- isFriendRequestConversation(conversation) ||
friend.avatarUrl ||
!friend.avatarObjectID ||
!friend.avatarKeyVersion
@@ -309,7 +263,7 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
const itemID = conversationId(conversation);
const itemFriendSpaceID = friendSpaceId(friend);
- void loadCurrentMessageConversationAvatar(actorSpaceId, friend)
+ void loadCurrentFriendAvatarURL(friend, actorSpaceId)
.then((avatarUrl) => {
if (
!avatarUrl ||
@@ -390,68 +344,11 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
const openConversation = React.useCallback(
(conversation: SpaceMessageConversation) => {
- if (isFriendRequestConversation(conversation)) return;
void router.push(spaceRoutes.message(conversationId(conversation)));
},
[router],
);
- const confirmFriendRequest = React.useCallback(
- async (conversation: SpaceMessageConversation) => {
- const actorSpaceId = profile?.spaceId;
- if (!actorSpaceId) throw new Error("Missing space.");
-
- try {
- await confirmCurrentFriendRequest(
- actorSpaceId,
- friendRequestIdFromConversation(conversation),
- );
- } catch (error: unknown) {
- if (!isFriendRequestCanceledError(error)) throw error;
- setConversations((currentConversations) =>
- currentConversations.filter(
- (candidate) =>
- conversationId(candidate) !=
- conversationId(conversation),
- ),
- );
- setShowFriendRequestCanceledToast(true);
- void refreshConversations();
- return;
- }
- window.location.reload();
- },
- [profile?.spaceId, refreshConversations],
- );
-
- const deleteFriendRequest = React.useCallback(
- async (conversation: SpaceMessageConversation) => {
- const actorSpaceId = profile?.spaceId;
- if (!actorSpaceId) throw new Error("Missing space.");
-
- try {
- await deleteCurrentFriendRequest(
- actorSpaceId,
- friendRequestIdFromConversation(conversation),
- );
- } catch (error: unknown) {
- if (!isFriendRequestCanceledError(error)) throw error;
- setConversations((currentConversations) =>
- currentConversations.filter(
- (candidate) =>
- conversationId(candidate) !=
- conversationId(conversation),
- ),
- );
- setShowFriendRequestCanceledToast(true);
- void refreshConversations();
- return;
- }
- void refreshConversations();
- },
- [profile?.spaceId, refreshConversations],
- );
-
const closeConversation = React.useCallback(() => {
if (selectedSpaceId) void router.push(spaceRoutes.messages);
}, [router, selectedSpaceId]);
@@ -705,12 +602,7 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
isThreadReadOnly={isThreadReadOnly}
isThreadRecipientLoading={isThreadRecipientLoading}
messages={messages}
- newConversationIds={newConversationIds}
- latestPostCreatedAtMs={latestPostCreatedAtMs}
- onBack={() => void router.push(spaceRoutes.home)}
onCloseThread={closeConversation}
- onConfirmFriendRequest={confirmFriendRequest}
- onDeleteFriendRequest={deleteFriendRequest}
onOpenSelectedFriendProfile={(friend) => {
const username = friend.username || friend.spaceSlug;
if (username)
@@ -729,44 +621,9 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
)
}
onOpenThread={openConversation}
- onPostPhotoSelect={(file) => {
- setPendingPostPhotoFiles(file);
- }}
onLoadActivityPost={(post) =>
- loadCurrentMessageActivityPostPreview(post, actorSpaceId)
+ loadCurrentPostPreview(post, actorSpaceId)
}
- onSendPoke={async (spaceId) => {
- const sender = currentProfileMessageActor(profile);
- const recipient =
- selectedFriend ?? placeholderFriend(spaceId);
- const optimisticMessage = createLocalMessage({
- kind: "poke",
- profile,
- recipient,
- text: "Poked",
- });
- appendMessageIfThreadIsCurrent(spaceId, optimisticMessage);
- try {
- const message = await sendCurrentPoke(
- actorSpaceId,
- spaceId,
- sender,
- recipient,
- );
- replaceMessageIfThreadIsCurrent(
- spaceId,
- optimisticMessage.id,
- message,
- );
- } catch (error) {
- removeMessageIfThreadIsCurrent(
- spaceId,
- optimisticMessage.id,
- );
- throw error;
- }
- void refreshConversations();
- }}
onSendMessage={async (spaceId, text) => {
const sender = currentProfileMessageActor(profile);
const recipient =
@@ -901,11 +758,6 @@ export const SpaceMessagesPage: React.FC<SpaceMessagesPageProps> = ({
profile={profile}
selectedFriend={selectedFriend}
/>
- {showFriendRequestCanceledToast && (
- <SpaceFriendRequestCanceledToast
- onClose={() => setShowFriendRequestCanceledToast(false)}
- />
- )}
</>
);
};
diff --git a/web/apps/space/src/components/MobileBestToast.tsx b/web/apps/space/src/components/MobileBestToast.tsx
index 0f0d6344a7..d8329b1a38 100644
--- a/web/apps/space/src/components/MobileBestToast.tsx
+++ b/web/apps/space/src/components/MobileBestToast.tsx
@@ -26,7 +26,7 @@ export const SpaceMobileBestToast: React.FC = () => {
sx={{
alignItems: "center",
bgcolor: spaceHomeSurface,
- borderRadius: "24px",
+ borderRadius: "32px",
boxShadow: "0 12px 32px rgba(0, 0, 0, 0.18)",
boxSizing: "border-box",
color: spaceText,
@@ -42,7 +42,7 @@ export const SpaceMobileBestToast: React.FC = () => {
pr: "6px",
py: "4px",
right: "calc(env(safe-area-inset-right) + 24px)",
- top: "calc(env(safe-area-inset-top) + 24px)",
+ top: "calc(env(safe-area-inset-top) + 20px)",
width: 366,
zIndex: 20,
}}
diff --git a/web/apps/space/src/components/PWAInstallPrompt.tsx b/web/apps/space/src/components/PWAInstallPrompt.tsx
index aab2827817..6360d78454 100644
--- a/web/apps/space/src/components/PWAInstallPrompt.tsx
+++ b/web/apps/space/src/components/PWAInstallPrompt.tsx
@@ -213,12 +213,12 @@ export const SpacePWAPromptBanner: React.FC<SpacePWAPromptBannerProps> = ({
position: "fixed",
top:
placement == "top"
- ? "calc(env(safe-area-inset-top) + 12px)"
+ ? "calc(env(safe-area-inset-top) + 8px)"
: undefined,
transform: hidden
? placement == "bottom"
? "translate(-50%, calc(100% + env(safe-area-inset-bottom) + 16px))"
- : "translate(-50%, calc(-100% - env(safe-area-inset-top) - 12px))"
+ : "translate(-50%, calc(-100% - env(safe-area-inset-top) - 8px))"
: "translate(-50%, 0)",
transition: "transform 180ms ease",
width: "100%",
@@ -233,7 +233,7 @@ export const SpacePWAPromptBanner: React.FC<SpacePWAPromptBannerProps> = ({
sx={{
alignItems: "center",
bgcolor: spaceHomeSurface,
- borderRadius: "24px",
+ borderRadius: "32px",
boxShadow: "0 12px 32px rgba(0, 0, 0, 0.18)",
color: textBase,
display: "flex",
diff --git a/web/apps/space/src/components/PostAvatar.tsx b/web/apps/space/src/components/PostAvatar.tsx
index dbd4b366d7..981068d32f 100644
--- a/web/apps/space/src/components/PostAvatar.tsx
+++ b/web/apps/space/src/components/PostAvatar.tsx
@@ -3,14 +3,12 @@ import { SpaceAvatarImage } from "components/AvatarImage";
import React from "react";
interface SpacePostAvatarProps {
- outerRing?: boolean;
ready: boolean;
size: number;
src?: string | null;
}
export const SpacePostAvatar: React.FC<SpacePostAvatarProps> = ({
- outerRing = false,
ready,
size,
src,
@@ -50,12 +48,10 @@ export const SpacePostAvatar: React.FC<SpacePostAvatarProps> = ({
<Box
aria-hidden
sx={{
- border: outerRing
- ? "1px solid rgba(255, 255, 255, 0.4)"
- : "1px solid rgba(255, 255, 255, 0.16)",
+ border: "1px solid rgba(255, 255, 255, 0.16)",
borderRadius: "50%",
- boxShadow: outerRing ? "none" : "0 1px 4px rgba(0, 0, 0, 0.24)",
- inset: outerRing ? -1 : 0,
+ boxShadow: "0 1px 4px rgba(0, 0, 0, 0.24)",
+ inset: 0,
pointerEvents: "none",
position: "absolute",
}}
diff --git a/web/apps/space/src/components/PostComposer.tsx b/web/apps/space/src/components/PostComposer.tsx
index 3bcc8ed45b..5e3f9a7474 100644
--- a/web/apps/space/src/components/PostComposer.tsx
+++ b/web/apps/space/src/components/PostComposer.tsx
@@ -49,16 +49,16 @@ let nextDraftPhotoID = 0;
const draftPhotos = (files: File[]): DraftPhoto[] =>
files.map((file) => ({ file, id: nextDraftPhotoID++ }));
-export const SpacePostComposer: React.FC<{
+const SpacePostComposer: React.FC<{
files: File[];
onClose: () => void;
onPublish: (
images: SpaceDraftPostImage[],
caption: string,
) => Promise<void>;
- onPublished?: () => void;
profile: SetupProfile;
-}> = ({ files, onClose, onPublish, onPublished, profile }) => {
+}> = ({ files, onClose, onPublish, profile }) => {
+ const router = useSpaceRouter();
const displayName =
profile.fullName.trim() || profile.username.trim() || "You";
const [drafts, setDrafts] = React.useState(() => draftPhotos(files));
@@ -429,11 +429,14 @@ export const SpacePostComposer: React.FC<{
exportsRef.current.clear();
setEditorSnapshot({ drafts, activeIndex });
}}
- onDraftPostExitStart={() => setIsPublishing(true)}
- onDraftPostExitAnimationStart={() => setIsExiting(true)}
- onDraftPostPublished={() => {
- void clearBrowserBackState("back").then(onPublished);
+ onDraftPostExitStart={async () => {
+ setIsPublishing(true);
+ await clearBrowserBackState("back");
+ if (router.pathname != spaceRoutes.home)
+ await router.replace(spaceRoutes.home);
+ window.scrollTo({ top: 0, behavior: "instant" });
}}
+ onDraftPostExitAnimationStart={() => setIsExiting(true)}
onPublishDraftPost={
preparationError || isPreparing || !drafts.length
? undefined
@@ -498,7 +501,6 @@ export const SpacePostComposerHost: React.FC = () => {
publishPost,
setPendingPostPhotoFiles,
} = useSpaceAppState();
- const router = useSpaceRouter();
if (!pendingPostPhotoFiles || !profile) return null;
return (
<SpacePostComposer
@@ -507,11 +509,6 @@ export const SpacePostComposerHost: React.FC = () => {
onPublish={async (images, caption) => {
await publishPost(images, caption);
}}
- onPublished={() => {
- if (router.pathname != spaceRoutes.home)
- void router.push(spaceRoutes.home);
- else window.scrollTo({ top: 0, behavior: "smooth" });
- }}
profile={profile}
/>
);
diff --git a/web/apps/space/src/components/PostGrid.tsx b/web/apps/space/src/components/PostGrid.tsx
index c06f871c72..285b913089 100644
--- a/web/apps/space/src/components/PostGrid.tsx
+++ b/web/apps/space/src/components/PostGrid.tsx
@@ -21,7 +21,6 @@ export const SpacePostGrid = <Item extends PostGridItem>({
renderTile: (item: Item, index: number) => React.ReactNode;
}) => {
const [width, setWidth] = React.useState(0);
- const [fullWidth, setFullWidth] = React.useState<boolean>();
const gridRef = React.useRef<HTMLDivElement | null>(null);
React.useLayoutEffect(() => {
@@ -34,10 +33,8 @@ export const SpacePostGrid = <Item extends PostGridItem>({
return () => observer.disconnect();
}, []);
- if (fullWidth == undefined && width > 0 && items.length > 0)
- setFullWidth(
- postCount != undefined && Math.max(postCount, items.length) < 4,
- );
+ const fullWidth =
+ postCount != undefined && Math.max(postCount, items.length) < 4;
const columnCount = fullWidth ? 1 : 2;
const columnWidth = (width - (columnCount - 1) * gap) / columnCount;
diff --git a/web/apps/space/src/components/PostPreviewThumbnail.tsx b/web/apps/space/src/components/PostPreviewThumbnail.tsx
new file mode 100644
index 0000000000..37f29e7e1a
--- /dev/null
+++ b/web/apps/space/src/components/PostPreviewThumbnail.tsx
@@ -0,0 +1,59 @@
+import { ImageDelete02Icon } from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
+import { Box } from "@mui/material";
+import { SpacePostVideoBadge } from "components/PostPhotosBadge";
+import type { SpacePostPreview } from "services/space";
+import { spaceSurfaceHover, spaceTextMuted } from "styles/colors";
+
+export const SpacePostPreviewThumbnail = ({
+ post,
+}: {
+ post?: SpacePostPreview;
+}) =>
+ post?.imageUrl ? (
+ <Box sx={{ position: "relative", width: 44, height: 44 }}>
+ <Box
+ component="img"
+ alt=""
+ src={post.imageUrl}
+ sx={{
+ borderRadius: "20%",
+ display: "block",
+ height: "100%",
+ objectFit: "cover",
+ objectPosition: "center",
+ width: "100%",
+ }}
+ />
+ <SpacePostVideoBadge durationMs={post.durationMs} />
+ </Box>
+ ) : (
+ <Box
+ aria-label={
+ post?.isUnavailable
+ ? "Post image unavailable"
+ : post?.hasLoadError
+ ? "Couldn't load post image"
+ : "Loading post image"
+ }
+ role="img"
+ sx={{
+ alignItems: "center",
+ bgcolor: spaceSurfaceHover,
+ borderRadius: "20%",
+ color: spaceTextMuted,
+ display: "flex",
+ height: 44,
+ justifyContent: "center",
+ width: 44,
+ }}
+ >
+ {post?.isUnavailable && (
+ <HugeiconsIcon
+ icon={ImageDelete02Icon}
+ size={18}
+ strokeWidth={1.5}
+ />
+ )}
+ </Box>
+ );
diff --git a/web/apps/space/src/components/PostTile.tsx b/web/apps/space/src/components/PostTile.tsx
index 0a64e982e0..06f09cd906 100644
--- a/web/apps/space/src/components/PostTile.tsx
+++ b/web/apps/space/src/components/PostTile.tsx
@@ -291,7 +291,6 @@ export const SpacePostTile: React.FC<SpacePostTileProps> = ({
}}
>
<SpacePostAvatar
- outerRing
ready={!isAvatarPending && decodedAvatar.ready}
size={26}
src={
diff --git a/web/apps/space/src/components/RouteFallback.tsx b/web/apps/space/src/components/RouteFallback.tsx
index 1efdfcab4b..75fc1679ad 100644
--- a/web/apps/space/src/components/RouteFallback.tsx
+++ b/web/apps/space/src/components/RouteFallback.tsx
@@ -52,7 +52,7 @@ export const SpaceRouteFallback: React.FC<SpaceRouteFallbackProps> = ({
alignItems: "center",
background: spaceAppBackground,
display: "grid",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
placeItems: "center",
px: 3,
textAlign: "center",
diff --git a/web/apps/space/src/pages/_app.tsx b/web/apps/space/src/pages/_app.tsx
index 01be0a86b1..17e272e006 100644
--- a/web/apps/space/src/pages/_app.tsx
+++ b/web/apps/space/src/pages/_app.tsx
@@ -2,6 +2,7 @@ import "@fontsource-variable/inter";
import "@fontsource/nunito/800.css";
import { CssBaseline } from "@mui/material";
import { createTheme, ThemeProvider } from "@mui/material/styles";
+import { SpaceAppLayout } from "components/AppNavigation";
import { SpacePostComposerHost } from "components/PostComposer";
import { SpaceRouteTransitionBoundary } from "components/RouteTransitionBoundary";
import "configure-zod";
@@ -153,7 +154,9 @@ const App: React.FC<AppProps> = ({ Component, pageProps }) => {
<CssBaseline enableColorScheme />
<SpaceRouteTransitionBoundary>
<SpaceAppStateProvider>
- <Component {...pageProps} />
+ <SpaceAppLayout>
+ <Component {...pageProps} />
+ </SpaceAppLayout>
<SpacePostComposerHost />
</SpaceAppStateProvider>
</SpaceRouteTransitionBoundary>
diff --git a/web/apps/space/src/pages/app/friends/index.tsx b/web/apps/space/src/pages/app/friends/index.tsx
index fee0ad00db..10b61a87f7 100644
--- a/web/apps/space/src/pages/app/friends/index.tsx
+++ b/web/apps/space/src/pages/app/friends/index.tsx
@@ -14,6 +14,7 @@ import {
loadCurrentSpaceFriends,
removeCurrentSpaceFriend,
requestFriendByUsername,
+ sendCurrentPoke,
type SpaceFriendRequest,
} from "services/space";
import { useSpaceAppState } from "state/app-state";
@@ -90,7 +91,6 @@ const Page: React.FC = () => {
friends={friends}
isLoading={isFriendsLoading}
onLoadFriendAvatar={loadCurrentFriendAvatarURL}
- onBack={() => void router.push(spaceRoutes.profile)}
onAddFriend={async (username) => {
const actorSpaceId = profile.spaceId;
if (!actorSpaceId) throw new Error("Missing space.");
@@ -119,6 +119,17 @@ const Page: React.FC = () => {
}
return status;
}}
+ onPoke={async (friendID, requestID) => {
+ const actorSpaceId = profile.spaceId;
+ const friend = friends.find((item) => item.id == friendID);
+ if (!actorSpaceId || !friend?.spaceId)
+ throw new Error("Missing space.");
+ await sendCurrentPoke(
+ actorSpaceId,
+ friend.spaceId,
+ requestID,
+ );
+ }}
onMessage={(friendID) => {
const friend = friends.find(
(candidate) => candidate.id == friendID,
diff --git a/web/apps/space/src/pages/app/index.tsx b/web/apps/space/src/pages/app/index.tsx
index 87799637de..c89c57aec6 100644
--- a/web/apps/space/src/pages/app/index.tsx
+++ b/web/apps/space/src/pages/app/index.tsx
@@ -18,13 +18,11 @@ import { loadExistingSpaceId } from "services/profile";
import {
clearSpaceFriendsCache,
deleteCurrentPost,
- hasCurrentSpacePosts,
loadCurrentFeedPage,
loadCurrentFriendRequests,
loadCurrentSpaceFriends,
loadCurrentSpacePostAssetURL,
loadCurrentSpacePostAvatarURL,
- loadCurrentUnreadStatus,
replyToCurrentPost,
requestFriendByUsername,
setCurrentPostLiked,
@@ -48,7 +46,6 @@ const Page: React.FC = () => {
retryPost,
setFriends,
setLocalFeedPosts,
- setPendingPostPhotoFiles,
} = useSpaceAppState();
const [friendRequestSentToastName, setFriendRequestSentToastName] =
useState<string>();
@@ -60,10 +57,7 @@ const Page: React.FC = () => {
const [feedSession, setFeedSession] = useState<SpaceFeedSession>();
const [hasFeedLoadMoreError, setHasFeedLoadMoreError] = useState(false);
const [feedNextCursor, setFeedNextCursor] = useState<string>();
- const [hasUnreadMessages, setHasUnreadMessages] = useState<boolean>();
- const [hasOwnPosts, setHasOwnPosts] = useState<boolean>();
const [isFeedLoading, setIsFeedLoading] = useState(true);
- const [isFeedComplete, setIsFeedComplete] = useState(false);
const [isFeedLoadingMore, setIsFeedLoadingMore] = useState(false);
const [isFriendsLoading, setIsFriendsLoading] = useState(true);
const [spaceId, setSpaceId] = useState<string>();
@@ -118,23 +112,6 @@ const Page: React.FC = () => {
};
}, [isAddFriendOpen, profile?.spaceId]);
- useEffect(() => {
- setHasOwnPosts(undefined);
- if (!spaceId) return;
-
- let cancelled = false;
- void hasCurrentSpacePosts(spaceId)
- .then((hasPosts) => {
- if (!cancelled) setHasOwnPosts(hasPosts);
- })
- .catch((error: unknown) =>
- log.error("Failed to check for own Space posts", error),
- );
- return () => {
- cancelled = true;
- };
- }, [spaceId]);
-
useEffect(() => {
const request = { cancelled: false };
const isCancelled = () => request.cancelled;
@@ -146,9 +123,7 @@ const Page: React.FC = () => {
setFeedSession(undefined);
setHasFeedLoadMoreError(false);
setFeedNextCursor(undefined);
- setHasUnreadMessages(undefined);
setIsFeedLoading(true);
- setIsFeedComplete(false);
setIsFeedLoadingMore(false);
setIsFriendsLoading(true);
void (async () => {
@@ -166,13 +141,6 @@ const Page: React.FC = () => {
setFeedNextCursor(
cachedFeed?.dirty ? undefined : cachedFeed?.nextCursor,
);
- setIsFeedComplete(
- Boolean(
- cachedFeed &&
- !cachedFeed.dirty &&
- !cachedFeed.nextCursor,
- ),
- );
};
if (savedSpaceId) {
loadedSpaceId = savedSpaceId;
@@ -211,7 +179,6 @@ const Page: React.FC = () => {
spaceFeedSessionItems(loadedFeedSession, feed.items),
);
setFeedNextCursor(feed.nextCursor);
- setIsFeedComplete(!feed.nextCursor);
const refreshedPostIDs = new Set(
feed.items.map((item) => item.postId),
);
@@ -231,20 +198,10 @@ const Page: React.FC = () => {
setIsFeedLoading(false);
if (!loadedSpaceId) {
- setHasUnreadMessages(false);
setIsFriendsLoading(false);
return;
}
- void loadCurrentUnreadStatus(loadedSpaceId)
- .then((unreadStatus) => {
- if (!isCancelled()) {
- setHasUnreadMessages(unreadStatus.messagesUnread);
- }
- })
- .catch((error: unknown) =>
- log.error("Failed to load space unread status", error),
- );
void loadCurrentSpaceFriends(loadedSpaceId)
.then((nextFriends) => {
if (!isCancelled()) setFriends(nextFriends);
@@ -283,7 +240,6 @@ const Page: React.FC = () => {
];
});
setFeedNextCursor(feed.nextCursor);
- setIsFeedComplete(!feed.nextCursor);
} catch (error) {
setHasFeedLoadMoreError(true);
log.error("Failed to load more space feed", error);
@@ -329,18 +285,11 @@ const Page: React.FC = () => {
feedItems={feedItems}
friendRequestSentToastName={friendRequestSentToastName}
hasFeedLoadMoreError={hasFeedLoadMoreError}
- hasUnreadMessages={hasUnreadMessages}
hasMoreFeedItems={!isFeedLoading && Boolean(feedNextCursor)}
isFeedLoading={isFeedLoading}
- isFeedComplete={isFeedComplete}
isFeedLoadingMore={isFeedLoadingMore}
localFeedPosts={localFeedPosts}
feedSession={feedSession}
- showFirstPostPrompt={
- hasOwnPosts === false &&
- localFeedPosts.length == 0 &&
- !feedItems.some((post) => post.spaceId == spaceId)
- }
profile={profile}
viewerSpaceId={spaceId ?? profile?.spaceId}
showInstallPrompt={
@@ -356,7 +305,6 @@ const Page: React.FC = () => {
onFriendRequestSentToastClose={closeFriendRequestSentToast}
onInviteFriendsToastClose={closeInviteFriendsToast}
onAddFriend={() => setIsAddFriendOpen(true)}
- onPostPhotoSelect={setPendingPostPhotoFiles}
onRetryPost={retryPost}
onDeletePost={async (postId) => {
const spaceId = profile?.spaceId;
@@ -420,7 +368,6 @@ const Page: React.FC = () => {
onLoadMoreFeedItems={loadMoreFeedItems}
onLoadPostAvatar={loadCurrentSpacePostAvatarURL}
onLoadPostImage={loadCurrentSpacePostAssetURL}
- onOpenMessages={() => void router.push(spaceRoutes.messages)}
onOpenProfile={
profile
? () => void router.push(spaceRoutes.profile)
@@ -494,7 +441,6 @@ const Page: React.FC = () => {
),
);
setFeedNextCursor(feed.nextCursor);
- setIsFeedComplete(!feed.nextCursor);
} else {
setFriendRequests(
await loadCurrentFriendRequests(
diff --git a/web/apps/space/src/pages/app/notifications.tsx b/web/apps/space/src/pages/app/notifications.tsx
new file mode 100644
index 0000000000..715d9de6b7
--- /dev/null
+++ b/web/apps/space/src/pages/app/notifications.tsx
@@ -0,0 +1,1103 @@
+import {
+ ArrowLeft02Icon,
+ Cancel01Icon,
+ FavouriteIcon,
+} from "@hugeicons/core-free-icons";
+import { HugeiconsIcon } from "@hugeicons/react";
+import { Box } from "@mui/material";
+import {
+ SpaceActivityAvatar,
+ SpaceActivityIdentity,
+ SpaceActivitySection,
+} from "components/ActivityList";
+import { SpaceFriendRequestCanceledToast } from "components/FriendRequestCanceledToast";
+import { SpacePageMeta } from "components/PageMeta";
+import { SpacePostPhotoInput } from "components/PostPhotoInput";
+import { SpacePostPreviewThumbnail } from "components/PostPreviewThumbnail";
+import { SpaceRouteFallback } from "components/RouteFallback";
+import { SpaceShareInviteButton } from "components/ShareInviteButton";
+import { SpaceSkipLink } from "components/SkipLink";
+import log from "ente-base/log";
+import React from "react";
+import { spaceInviteURL } from "services/invite";
+import {
+ confirmCurrentFriendRequest,
+ deleteCurrentFriendRequest,
+ loadCurrentFriendAvatarURL,
+ loadCurrentNotifications,
+ loadCurrentPostPreview,
+ loadCurrentSpaceFriendsCount,
+ markCurrentNotificationItemsRead,
+ type SpaceNotification,
+ type SpacePostPreview,
+} from "services/space";
+import { useSpaceAppState } from "state/app-state";
+import {
+ spaceActivityListSx,
+ spaceActivityPreviewSx,
+ spaceActivityRowSx,
+} from "styles/activity-list";
+import { spaceEmptyStateButtonSx } from "styles/buttons";
+import {
+ spaceAppBackgroundColor,
+ spaceControlBackground,
+ spaceControlBackgroundHover,
+ spaceOnAccent,
+ spaceSurfaceHover,
+ spaceText,
+ spaceTextMuted,
+} from "styles/colors";
+import { groupSpaceActivities } from "utils/activity-sections";
+import { isFriendRequestCanceledError } from "utils/friend-errors";
+import { spacePostDeletedEvent } from "utils/post-events";
+import { postQuoteErrorState } from "utils/post-quote";
+import { useSpaceRouter } from "utils/route-transitions";
+import { spaceRoutes } from "utils/routes";
+
+const NotificationAvatar: React.FC<{
+ actor: SpaceNotification["actors"][number];
+ spaceId: string;
+}> = ({ actor, spaceId }) => {
+ const [avatarURL, setAvatarURL] = React.useState<string | null | undefined>(
+ actor.avatarUrl ?? undefined,
+ );
+ const hasAvatar = Boolean(actor.avatarObjectID && actor.avatarKeyVersion);
+ React.useEffect(() => {
+ if (actor.avatarUrl || !hasAvatar) return;
+ let cancelled = false;
+ void loadCurrentFriendAvatarURL(actor, spaceId)
+ .catch((error: unknown) => {
+ log.warn("Failed to load notification avatar", error);
+ return null;
+ })
+ .then((url) => {
+ if (!cancelled) setAvatarURL(url);
+ });
+ return () => {
+ cancelled = true;
+ };
+ }, [actor, hasAvatar, spaceId]);
+ return (
+ <SpaceActivityAvatar
+ avatarUrl={actor.avatarUrl || avatarURL}
+ loading={hasAvatar && !actor.avatarUrl && avatarURL === undefined}
+ size={44}
+ />
+ );
+};
+
+const actorName = (actor: SpaceNotification["actors"][number]) =>
+ actor.fullName.trim() || actor.username;
+
+const NotificationRow: React.FC<{
+ group: SpaceNotification;
+ spaceId: string;
+ loadPostPreview: (postId: number) => Promise<SpacePostPreview | undefined>;
+ onPostSomething: () => void;
+ showPostSomething: boolean;
+ isOpeningPost: boolean;
+ onFriendRequest: (
+ group: SpaceNotification,
+ accept: boolean,
+ ) => Promise<void>;
+}> = ({
+ group,
+ spaceId,
+ loadPostPreview,
+ onFriendRequest,
+ onPostSomething,
+ showPostSomething,
+ isOpeningPost,
+}) => {
+ const router = useSpaceRouter();
+ const rowRef = React.useRef<HTMLDivElement>(null);
+ const [preview, setPreview] = React.useState<SpacePostPreview>();
+ const actor = group.actors[0]!;
+ const otherCount = group.actorCount - 1;
+ const isFriendRequest = group.kind == "friend_request";
+ const isPostLike = group.kind == "post_like";
+ const [isRequestPending, setIsRequestPending] = React.useState(false);
+ const [requestError, setRequestError] = React.useState<string>();
+ const actOnRequest = async (accept: boolean) => {
+ setIsRequestPending(true);
+ setRequestError(undefined);
+ try {
+ await onFriendRequest(group, accept);
+ } catch (error) {
+ log.error("Failed to update friend request", error);
+ setRequestError(
+ accept
+ ? "Couldn't accept request. Try again."
+ : "Couldn't dismiss request. Try again.",
+ );
+ setIsRequestPending(false);
+ }
+ };
+ React.useEffect(() => {
+ if (group.postId === undefined) return;
+ const postId = group.postId;
+ let cancelled = false;
+ const observer = new IntersectionObserver(
+ (entries) => {
+ if (!entries.some((entry) => entry.isIntersecting)) return;
+ observer.disconnect();
+ void loadPostPreview(postId).then((post) => {
+ if (!cancelled) setPreview(post);
+ });
+ },
+ { rootMargin: "200px 0px" },
+ );
+ if (rowRef.current) observer.observe(rowRef.current);
+ return () => {
+ cancelled = true;
+ observer.disconnect();
+ };
+ }, [group.postId, loadPostPreview]);
+
+ return (
+ <Box component="li" sx={{ listStyle: "none" }}>
+ <Box
+ ref={rowRef}
+ data-notification-id={group.id}
+ sx={{
+ ...spaceActivityRowSx,
+ gridTemplateColumns:
+ isFriendRequest || showPostSomething
+ ? "44px minmax(0, 1fr) auto"
+ : "44px minmax(0, 1fr)",
+ "&:has(> [data-space-row-action]:hover), &:has(> [data-space-row-action]:active)":
+ { bgcolor: "transparent" },
+ ...(isFriendRequest && {
+ "&:hover, &:active": { bgcolor: "transparent" },
+ }),
+ }}
+ >
+ <Box
+ component={isFriendRequest ? "div" : "button"}
+ type={isFriendRequest ? undefined : "button"}
+ aria-label={
+ isFriendRequest
+ ? undefined
+ : `Open ${actorName(actor)}'s profile`
+ }
+ onClick={
+ isFriendRequest
+ ? undefined
+ : () =>
+ void router.push(
+ spaceRoutes.friendPage,
+ spaceRoutes.friend(actor.username),
+ )
+ }
+ sx={{
+ appearance: "none",
+ bgcolor: "transparent",
+ border: 0,
+ borderRadius: "50%",
+ cursor: isFriendRequest ? "default" : "pointer",
+ display: "block",
+ height: 44,
+ p: 0,
+ width: 44,
+ "&:focus-visible": {
+ outline: "2px solid #08C225",
+ outlineOffset: 2,
+ },
+ }}
+ >
+ <NotificationAvatar
+ key={`${actor.id}:${actor.avatarObjectID}:${actor.avatarKeyVersion}`}
+ actor={actor}
+ spaceId={spaceId}
+ />
+ </Box>
+ <Box
+ component={isFriendRequest ? "div" : "button"}
+ type={isFriendRequest ? undefined : "button"}
+ onClick={
+ isFriendRequest
+ ? undefined
+ : () => {
+ if (isPostLike)
+ void router.push(
+ spaceRoutes.post(
+ spaceId,
+ group.postId!,
+ ),
+ );
+ else
+ void router.push(
+ spaceRoutes.friendPage,
+ spaceRoutes.friend(actor.username),
+ );
+ }
+ }
+ sx={{
+ alignItems: "center",
+ appearance: "none",
+ bgcolor: "transparent",
+ border: 0,
+ color: "inherit",
+ cursor: isFriendRequest ? "default" : "pointer",
+ display: "grid",
+ gap: "10px",
+ gridTemplateColumns: isPostLike
+ ? "minmax(0, 1fr) 44px"
+ : "minmax(0, 1fr)",
+ minWidth: 0,
+ p: 0,
+ textAlign: "left",
+ width: "100%",
+ "&:focus-visible": {
+ borderRadius: "8px",
+ outline: "2px solid #08C225",
+ outlineOffset: 2,
+ },
+ }}
+ >
+ <Box sx={{ minWidth: 0 }}>
+ <SpaceActivityIdentity
+ name={
+ <>
+ {isFriendRequest
+ ? `@${actor.username}`
+ : actorName(actor)}
+ {otherCount > 0 && (
+ <>
+ <Box
+ component="span"
+ sx={{ fontWeight: 400 }}
+ >
+ {" and "}
+ </Box>
+ {otherCount == 1
+ ? actorName(group.actors[1]!)
+ : `${otherCount} others`}
+ </>
+ )}
+ </>
+ }
+ createdAtMs={group.createdAtMs}
+ />
+ <Box sx={spaceActivityPreviewSx}>
+ {isPostLike
+ ? "Liked your post"
+ : 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>
+ )}
+ </Box>
+ {showPostSomething && (
+ <Box
+ className="green-bg"
+ component="button"
+ type="button"
+ data-space-row-action
+ disabled={isOpeningPost}
+ onClick={onPostSomething}
+ sx={{
+ bgcolor: "#08C225",
+ border: 0,
+ borderRadius: "16px",
+ color: spaceOnAccent,
+ cursor: "pointer",
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 12,
+ fontWeight: 700,
+ height: 36,
+ px: "12px",
+ whiteSpace: "nowrap",
+ "&:focus-visible": {
+ outline: "2px solid #08C225",
+ outlineOffset: 2,
+ },
+ "&:hover": { bgcolor: "#07A820" },
+ }}
+ >
+ Post a photo
+ </Box>
+ )}
+ {isFriendRequest && (
+ <Box
+ sx={{
+ display: "flex",
+ flexShrink: 0,
+ gap: "4px",
+ mr: "-6px",
+ }}
+ >
+ <Box
+ className="green-bg"
+ component="button"
+ type="button"
+ disabled={isRequestPending}
+ onClick={() => void actOnRequest(true)}
+ sx={{
+ bgcolor: "#08C225",
+ border: 0,
+ borderRadius: "12px",
+ color: spaceOnAccent,
+ cursor: "pointer",
+ fontFamily:
+ '"Inter Variable", Inter, sans-serif',
+ fontSize: 12,
+ fontWeight: 700,
+ height: 34,
+ px: "12px",
+ "&:hover": { bgcolor: "#07A820" },
+ }}
+ >
+ Accept
+ </Box>
+ <Box
+ component="button"
+ type="button"
+ aria-label={`Dismiss friend request from ${actor.username}`}
+ disabled={isRequestPending}
+ onClick={() => void actOnRequest(false)}
+ sx={{
+ alignItems: "center",
+ bgcolor: "transparent",
+ border: 0,
+ borderRadius: "50%",
+ color: spaceText,
+ cursor: "pointer",
+ display: "flex",
+ height: 34,
+ justifyContent: "center",
+ p: 0,
+ width: 34,
+ "&:hover": { bgcolor: spaceSurfaceHover },
+ }}
+ >
+ <HugeiconsIcon
+ icon={Cancel01Icon}
+ size={18}
+ strokeWidth={2}
+ />
+ </Box>
+ </Box>
+ )}
+ {requestError && (
+ <Box
+ role="alert"
+ sx={{
+ ...spaceActivityPreviewSx,
+ gridColumn: "2 / -1",
+ whiteSpace: "normal",
+ }}
+ >
+ {requestError}
+ </Box>
+ )}
+ </Box>
+ </Box>
+ );
+};
+
+const NotificationLoadingDots = () => (
+ <Box
+ role="status"
+ aria-label="Loading more notifications"
+ sx={{
+ display: "flex",
+ justifyContent: "center",
+ alignItems: "center",
+ gap: "5px",
+ height: 48,
+ }}
+ >
+ {[0, 1, 2].map((index) => (
+ <Box
+ key={index}
+ component="span"
+ aria-hidden
+ sx={{
+ width: 5,
+ height: 5,
+ borderRadius: "50%",
+ bgcolor: "#08C225",
+ animation: "spaceNotificationDot 1.2s ease-in-out infinite",
+ animationDelay: `${index * 0.15}s`,
+ "@keyframes spaceNotificationDot": {
+ "0%, 60%, 100%": {
+ opacity: 0.3,
+ transform: "translateY(0)",
+ },
+ "30%": { opacity: 1, transform: "translateY(-3px)" },
+ },
+ "@media (prefers-reduced-motion: reduce)": {
+ animation: "none",
+ },
+ }}
+ />
+ ))}
+ </Box>
+);
+
+const NotificationRetry = ({
+ message,
+ onRetry,
+ fullPage = false,
+}: {
+ message: string;
+ onRetry: () => void;
+ fullPage?: boolean;
+}) => (
+ <Box
+ role="alert"
+ sx={{
+ alignItems: "center",
+ display: "flex",
+ flexDirection: "column",
+ gap: fullPage ? "22px" : "12px",
+ justifyContent: "center",
+ minHeight: fullPage
+ ? "calc(var(--space-page-height, 100svh) - 90px - env(safe-area-inset-top) - env(safe-area-inset-bottom))"
+ : undefined,
+ px: 3,
+ py: fullPage ? 0 : 2,
+ textAlign: "center",
+ }}
+ >
+ <Box
+ component="p"
+ sx={{
+ color: spaceTextMuted,
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 14,
+ fontWeight: 500,
+ lineHeight: "20px",
+ m: 0,
+ maxWidth: 260,
+ }}
+ >
+ {message}
+ </Box>
+ <Box
+ component="button"
+ type="button"
+ onClick={onRetry}
+ sx={{
+ ...spaceEmptyStateButtonSx,
+ bgcolor: spaceControlBackground,
+ color: "#DEDEDE",
+ fontSize: 13,
+ minWidth: 116,
+ px: "18px",
+ "&:hover:not(:disabled)": {
+ bgcolor: spaceControlBackgroundHover,
+ },
+ }}
+ >
+ Retry
+ </Box>
+ </Box>
+);
+
+const NotificationsFeed: React.FC<{ spaceId: string; profileLink: string }> = ({
+ spaceId,
+ profileLink,
+}) => {
+ const { pendingPostPhotoFiles, setPendingPostPhotoFiles, postPublication } =
+ useSpaceAppState();
+ const postInputRef = React.useRef<HTMLInputElement>(null);
+ const [latestPostCreatedAtMs, setLatestPostCreatedAtMs] = React.useState<
+ number | null
+ >();
+ const [items, setItems] = React.useState<SpaceNotification[]>([]);
+ const [cursor, setCursor] = React.useState<string>();
+ const [newIDs, setNewIDs] = React.useState(new Set<string>());
+ const [loading, setLoading] = React.useState<
+ "refresh" | "more" | undefined
+ >("refresh");
+ const [loadError, setLoadError] = React.useState<"refresh" | "more">();
+ const [failedReadIDs, setFailedReadIDs] = React.useState<string[]>([]);
+ const [refresh, setRefresh] = React.useState(0);
+ const [showFriendRequestCanceledToast, setShowFriendRequestCanceledToast] =
+ React.useState(false);
+ const [friendsCount, setFriendsCount] = React.useState<number>();
+ const [isInviteSharing, setIsInviteSharing] = React.useState(false);
+ const showInviteEmptyState = friendsCount == 0 && Boolean(profileLink);
+ const emptyNotificationsCopy =
+ friendsCount == 0
+ ? "No notifications yet. Once you add friends, you'll see their likes and comments here."
+ : "No notifications yet. You'll see likes, comments and friend requests here.";
+ const handleFriendRequest = async (
+ group: SpaceNotification,
+ accept: boolean,
+ ) => {
+ try {
+ if (accept) {
+ await confirmCurrentFriendRequest(
+ spaceId,
+ group.friendRequestId!,
+ );
+ window.location.reload();
+ return;
+ } else
+ await deleteCurrentFriendRequest(
+ spaceId,
+ group.friendRequestId!,
+ );
+ } catch (error) {
+ if (!isFriendRequestCanceledError(error)) throw error;
+ setShowFriendRequestCanceledToast(true);
+ }
+ setItems((current) => current.filter((item) => item.id != group.id));
+ setRefresh((current) => current + 1);
+ };
+ React.useEffect(() => {
+ if (postPublication?.phase == "posted")
+ setRefresh((current) => current + 1);
+ }, [postPublication?.phase]);
+ const listRef = React.useRef<HTMLDivElement>(null);
+ const postPreviews = React.useRef({
+ generation: refresh,
+ items: new Map<number, Promise<SpacePostPreview | undefined>>(),
+ });
+ const loadMoreRef = React.useRef<HTMLDivElement>(null);
+ const loadingMore = React.useRef(false);
+ const attemptedReadIDs = React.useRef(new Set<string>());
+ const readIDs = React.useRef(new Set<string>());
+ const loadedPageCount = React.useRef(1);
+ const mounted = React.useRef(true);
+ const loadGeneration = React.useRef(0);
+
+ const loadPostPreview = React.useCallback(
+ (postId: number) => {
+ if (postPreviews.current.generation != refresh) {
+ postPreviews.current = {
+ generation: refresh,
+ items: new Map(),
+ };
+ }
+ let preview = postPreviews.current.items.get(postId);
+ if (!preview) {
+ const target = { spaceId, postId };
+ preview = loadCurrentPostPreview(target, spaceId)
+ .then((post) => post ?? { ...target, isUnavailable: true })
+ .catch((error: unknown) => {
+ log.warn("Failed to load notification post", error);
+ return { ...target, ...postQuoteErrorState(error) };
+ });
+ postPreviews.current.items.set(postId, preview);
+ }
+ return preview;
+ },
+ [spaceId, refresh],
+ );
+
+ const sections = React.useMemo(
+ () =>
+ groupSpaceActivities(items, (group) => ({
+ createdAtMs: group.createdAtMs,
+ isNew: newIDs.has(group.id),
+ })).filter((section) => section.items.length > 0),
+ [items, newIDs],
+ );
+
+ React.useEffect(() => {
+ mounted.current = true;
+ return () => {
+ mounted.current = false;
+ };
+ }, []);
+
+ React.useEffect(() => {
+ loadGeneration.current++;
+ loadingMore.current = false;
+ readIDs.current.forEach((id) => attemptedReadIDs.current.delete(id));
+ readIDs.current.clear();
+ let cancelled = false;
+ setLoading("refresh");
+ setLoadError(undefined);
+ const reloadPages = async () => {
+ const page = await loadCurrentNotifications(spaceId);
+ let pageCount = 1;
+ while (
+ !cancelled &&
+ page.nextCursor &&
+ pageCount < loadedPageCount.current
+ ) {
+ const nextPage = await loadCurrentNotifications(
+ spaceId,
+ page.nextCursor,
+ );
+ page.items.push(...nextPage.items);
+ page.nextCursor = nextPage.nextCursor;
+ pageCount++;
+ }
+ return {
+ ...page,
+ friendsCount:
+ page.items.length == 0
+ ? await loadCurrentSpaceFriendsCount(spaceId)
+ : undefined,
+ items: [
+ ...new Map(
+ page.items.map((item) => [
+ `${item.kind}:${item.postId ?? item.id}`,
+ item,
+ ]),
+ ).values(),
+ ],
+ pageCount,
+ };
+ };
+ void reloadPages()
+ .then((page) => {
+ if (cancelled) return;
+ loadedPageCount.current = page.pageCount;
+ setFriendsCount(page.friendsCount);
+ setLatestPostCreatedAtMs(page.latestPostCreatedAtMs);
+ setItems(
+ page.items.map((item) => ({
+ ...item,
+ read: item.read || readIDs.current.has(item.id),
+ })),
+ );
+ setNewIDs(
+ (current) =>
+ new Set([
+ ...current,
+ ...page.items
+ .filter((item) => !item.read)
+ .map((item) => item.id),
+ ]),
+ );
+ setCursor(page.nextCursor);
+ setFailedReadIDs((current) =>
+ current.filter((id) =>
+ page.items.some((item) => item.id == id && !item.read),
+ ),
+ );
+ })
+ .catch((error: unknown) => {
+ log.error("Failed to load notifications", error);
+ if (!cancelled) setLoadError("refresh");
+ })
+ .finally(() => {
+ if (!cancelled) setLoading(undefined);
+ });
+ return () => {
+ cancelled = true;
+ };
+ }, [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));
+ try {
+ for (let offset = 0; offset < ids.length; offset += 100) {
+ await markCurrentNotificationItemsRead(
+ spaceId,
+ ids.slice(offset, offset + 100),
+ );
+ }
+ if (!mounted.current) return;
+ ids.forEach((id) => readIDs.current.add(id));
+ setItems((current) =>
+ current.map((item) =>
+ ids.includes(item.id) ? { ...item, read: true } : item,
+ ),
+ );
+ setFailedReadIDs((current) =>
+ current.filter((id) => !ids.includes(id)),
+ );
+ } catch (error) {
+ log.error("Failed to mark notifications read", error);
+ if (mounted.current)
+ setFailedReadIDs((current) => [
+ ...new Set([...current, ...ids]),
+ ]);
+ }
+ },
+ [spaceId],
+ );
+
+ React.useEffect(() => {
+ const unreadIDs = new Set(
+ items.filter((item) => !item.read).map((item) => item.id),
+ );
+ const observer = new IntersectionObserver(
+ (entries) => {
+ if (document.visibilityState != "visible") return;
+ const ids = entries
+ .filter(
+ (entry) =>
+ entry.isIntersecting &&
+ entry.intersectionRatio >= 0.5,
+ )
+ .map(
+ (entry) =>
+ (entry.target as HTMLElement).dataset
+ .notificationId!,
+ )
+ .filter(
+ (id) =>
+ unreadIDs.has(id) &&
+ !attemptedReadIDs.current.has(id),
+ );
+ if (ids.length > 0) void markRead(ids);
+ },
+ { threshold: 0.5 },
+ );
+ const observeVisibleRows = () => {
+ observer.disconnect();
+ if (document.visibilityState != "visible") return;
+ listRef.current
+ ?.querySelectorAll("[data-notification-id]")
+ .forEach((row) => observer.observe(row));
+ };
+ observeVisibleRows();
+ document.addEventListener("visibilitychange", observeVisibleRows);
+ return () => {
+ observer.disconnect();
+ document.removeEventListener(
+ "visibilitychange",
+ observeVisibleRows,
+ );
+ };
+ }, [items, markRead]);
+
+ const loadMore = React.useCallback(async () => {
+ if (!cursor || loading || loadingMore.current) return;
+ loadingMore.current = true;
+ const generation = loadGeneration.current;
+ setLoading(window.scrollY > 0 ? "more" : "refresh");
+ setLoadError(undefined);
+ try {
+ const page = await loadCurrentNotifications(spaceId, cursor);
+ if (!mounted.current || generation != loadGeneration.current)
+ return;
+ loadedPageCount.current++;
+ setItems((current) => [
+ ...current,
+ ...page.items.filter(
+ (item) =>
+ !current.some(
+ (existing) =>
+ existing.kind == item.kind &&
+ (existing.postId ?? existing.id) ==
+ (item.postId ?? item.id),
+ ),
+ ),
+ ]);
+ setNewIDs(
+ (current) =>
+ new Set([
+ ...current,
+ ...page.items
+ .filter((item) => !item.read)
+ .map((item) => item.id),
+ ]),
+ );
+ setCursor(page.nextCursor);
+ } catch (error) {
+ log.error("Failed to load more notifications", error);
+ if (mounted.current && generation == loadGeneration.current)
+ setLoadError("more");
+ } finally {
+ if (mounted.current && generation == loadGeneration.current) {
+ loadingMore.current = false;
+ setLoading(undefined);
+ }
+ }
+ }, [cursor, loading, spaceId]);
+
+ React.useEffect(() => {
+ const sentinel = loadMoreRef.current;
+ if (!sentinel || !cursor || loading || loadError) return;
+ const observer = new IntersectionObserver(
+ (entries) => {
+ if (entries.some((entry) => entry.isIntersecting))
+ void loadMore();
+ },
+ { rootMargin: "300px 0px" },
+ );
+ observer.observe(sentinel);
+ return () => observer.disconnect();
+ }, [cursor, loading, loadError, loadMore]);
+
+ return (
+ <>
+ <SpacePostPhotoInput
+ inputRef={postInputRef}
+ onSelect={setPendingPostPhotoFiles}
+ />
+ {showFriendRequestCanceledToast && (
+ <SpaceFriendRequestCanceledToast
+ onClose={() => setShowFriendRequestCanceledToast(false)}
+ />
+ )}
+ {failedReadIDs.length > 0 && (
+ <NotificationRetry
+ message="Couldn't mark notifications as read."
+ onRetry={() => void markRead(failedReadIDs)}
+ />
+ )}
+ <Box ref={listRef}>
+ {sections.map((section) => (
+ <SpaceActivitySection
+ key={section.title}
+ title={section.title}
+ >
+ {section.items.map((group) => (
+ <NotificationRow
+ key={`${group.kind}:${group.postId ?? group.id}`}
+ group={group}
+ spaceId={spaceId}
+ loadPostPreview={loadPostPreview}
+ onFriendRequest={handleFriendRequest}
+ onPostSomething={() =>
+ postInputRef.current?.click()
+ }
+ isOpeningPost={Boolean(pendingPostPhotoFiles)}
+ showPostSomething={
+ group.kind == "poke" &&
+ latestPostCreatedAtMs !== undefined &&
+ (latestPostCreatedAtMs === null ||
+ latestPostCreatedAtMs <
+ group.createdAtMs)
+ }
+ />
+ ))}
+ </SpaceActivitySection>
+ ))}
+ </Box>
+ {!loading && !loadError && items.length == 0 && (
+ <Box
+ sx={{
+ alignItems: "center",
+ boxSizing: "border-box",
+ display: "flex",
+ flexDirection: "column",
+ gap: "22px",
+ inset: 0,
+ justifyContent: "center",
+ pointerEvents: "none",
+ position: "absolute",
+ px: 3,
+ textAlign: "center",
+ }}
+ >
+ <Box
+ component="p"
+ sx={{
+ color: spaceTextMuted,
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 14,
+ fontWeight: 500,
+ lineHeight: "20px",
+ m: 0,
+ maxWidth: 260,
+ }}
+ >
+ {emptyNotificationsCopy}
+ </Box>
+ {showInviteEmptyState && (
+ <SpaceShareInviteButton
+ profileLink={profileLink}
+ sharing={isInviteSharing}
+ onShareError={(error) =>
+ log.error("Failed to share space invite", error)
+ }
+ onSharingChange={setIsInviteSharing}
+ />
+ )}
+ </Box>
+ )}
+ {loadError && (
+ <NotificationRetry
+ fullPage={items.length == 0}
+ message={
+ loadError == "more"
+ ? "Couldn't load more notifications."
+ : items.length > 0
+ ? "Couldn't refresh notifications."
+ : "Couldn't load notifications."
+ }
+ onRetry={() =>
+ loadError == "more"
+ ? void loadMore()
+ : setRefresh((value) => value + 1)
+ }
+ />
+ )}
+ {cursor && (
+ <Box ref={loadMoreRef} sx={{ minHeight: 48 }}>
+ {loading == "more" && <NotificationLoadingDots />}
+ </Box>
+ )}
+ </>
+ );
+};
+
+const Page: React.FC = () => {
+ const router = useSpaceRouter();
+ const { profile, profileLoadStatus, profileLoadError } = useSpaceAppState();
+ React.useEffect(() => {
+ if (profileLoadStatus == "ready" && !profile)
+ void router.replace(spaceRoutes.onboarding);
+ }, [profile, profileLoadStatus, router]);
+
+ if (profileLoadStatus != "ready" || !profile?.spaceId) {
+ return (
+ <SpaceRouteFallback
+ background={spaceAppBackgroundColor}
+ message={profileLoadError}
+ />
+ );
+ }
+
+ return (
+ <>
+ <SpacePageMeta themeColor={spaceAppBackgroundColor} />
+ <SpaceSkipLink />
+ <Box
+ sx={{
+ bgcolor: spaceAppBackgroundColor,
+ color: spaceText,
+ minHeight: "var(--space-page-height, 100dvh)",
+ pt: "env(safe-area-inset-top)",
+ pb: "env(safe-area-inset-bottom)",
+ }}
+ >
+ <Box
+ sx={{
+ width: "100%",
+ mx: "auto",
+ minHeight:
+ "calc(var(--space-page-height, 100svh) - env(safe-area-inset-top) - env(safe-area-inset-bottom))",
+ position: "relative",
+ "@media (min-width: 600px)": { maxWidth: 390 },
+ }}
+ >
+ <Box
+ component="header"
+ sx={{
+ display: "grid",
+ alignItems: "center",
+ gridTemplateColumns: "44px 1fr 44px",
+ height: 56,
+ px: 2,
+ }}
+ >
+ <Box
+ component="button"
+ type="button"
+ aria-label="Back to home"
+ onClick={() => void router.push(spaceRoutes.home)}
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ justifyContent: "flex-start",
+ width: 44,
+ height: 44,
+ border: 0,
+ borderRadius: "50%",
+ bgcolor: "transparent",
+ ml: "-2px",
+ p: 0,
+ color: spaceText,
+ cursor: "pointer",
+ "&:focus-visible": {
+ outline: "2px solid #08C225",
+ },
+ }}
+ >
+ <HugeiconsIcon
+ icon={ArrowLeft02Icon}
+ size={24}
+ strokeWidth={1.8}
+ />
+ </Box>
+ <Box
+ component="h1"
+ sx={{
+ fontFamily:
+ '"Inter Variable", Inter, sans-serif',
+ fontSize: 18,
+ fontWeight: 700,
+ lineHeight: "24px",
+ justifySelf: "center",
+ m: 0,
+ }}
+ >
+ Notifications
+ </Box>
+ </Box>
+ <Box
+ component="main"
+ id="space-main-content"
+ tabIndex={-1}
+ sx={spaceActivityListSx}
+ >
+ <NotificationsFeed
+ key={profile.spaceId}
+ spaceId={profile.spaceId}
+ profileLink={spaceInviteURL({
+ spaceUsername: profile.username,
+ })}
+ />
+ </Box>
+ </Box>
+ </Box>
+ </>
+ );
+};
+
+export default Page;
diff --git a/web/apps/space/src/pages/app/post.tsx b/web/apps/space/src/pages/app/post.tsx
index e317878126..4af2897546 100644
--- a/web/apps/space/src/pages/app/post.tsx
+++ b/web/apps/space/src/pages/app/post.tsx
@@ -1,7 +1,6 @@
import { AddSquareIcon } from "@hugeicons/core-free-icons";
import { HugeiconsIcon } from "@hugeicons/react";
import { Box } from "@mui/material";
-import { SpaceBackIcon } from "components/BackIcon";
import { SpacePageMeta } from "components/PageMeta";
import { SpacePostPhotoInput } from "components/PostPhotoInput";
import { SpaceRouteFallback } from "components/RouteFallback";
@@ -14,12 +13,10 @@ import {
spaceText,
spaceTextMuted,
} from "styles/colors";
-import { spaceTouchTargetSize } from "styles/touch-targets";
import { useSpaceRouter } from "utils/route-transitions";
import { spaceRoutes } from "utils/routes";
const background = spaceAppBackgroundColor;
-const green = "#08C225";
const textBase = spaceText;
const textSecondary = spaceTextMuted;
@@ -59,7 +56,7 @@ const Page: React.FC = () => {
background: spaceAppBackground,
color: textBase,
display: "grid",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
placeItems: { xs: "stretch", sm: "start center" },
}}
>
@@ -67,59 +64,25 @@ const Page: React.FC = () => {
sx={{
boxSizing: "border-box",
display: "grid",
- gridTemplateRows: "56px minmax(0, 1fr)",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
mx: "auto",
+ position: "relative",
width: "100%",
"@media (min-width: 600px)": { maxWidth: 390 },
}}
>
- <Box
- component="header"
- sx={{
- alignItems: "center",
- display: "flex",
- height: 56,
- px: 2,
- }}
- >
- <Box
- component="button"
- type="button"
- aria-label="Back to Space"
- onClick={() => void router.push(spaceRoutes.home)}
- sx={{
- alignItems: "center",
- bgcolor: "transparent",
- border: 0,
- borderRadius: "50%",
- color: textBase,
- cursor: "pointer",
- display: "flex",
- height: spaceTouchTargetSize,
- justifyContent: "flex-start",
- ml: "-2px",
- p: 0,
- width: spaceTouchTargetSize,
- "&:focus-visible": {
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- }}
- >
- <SpaceBackIcon />
- </Box>
- </Box>
<Box
component="section"
sx={{
alignItems: "center",
- alignSelf: "center",
display: "flex",
flexDirection: "column",
+ position: "absolute",
px: "28px",
- pb: "48px",
textAlign: "center",
+ top: "calc(var(--space-viewport-height, 100svh) / 2)",
+ transform: "translateY(-50%)",
+ width: "100%",
}}
>
<Box
diff --git a/web/apps/space/src/pages/app/profile.tsx b/web/apps/space/src/pages/app/profile.tsx
index c465c96641..8c64eb00c7 100644
--- a/web/apps/space/src/pages/app/profile.tsx
+++ b/web/apps/space/src/pages/app/profile.tsx
@@ -27,7 +27,8 @@ const Page: React.FC = () => {
profile,
profileLoadError,
profileLoadStatus,
- publishPost,
+ pendingPostPhotoFiles,
+ setPendingPostPhotoFiles,
setLocalFeedPosts,
setPostPublication,
} = useSpaceAppState();
@@ -121,15 +122,13 @@ const Page: React.FC = () => {
<ProfileScreen
friendsCount={friendsCount}
isPostsLoading={isPostsLoading}
+ isPostPhotoOpening={Boolean(pendingPostPhotoFiles)}
isStatsLoading={isPostsLoading}
postItems={postItems}
profile={profile}
showPostLoadingIndicator={showInitialPostLoadingIndicator}
onBack={() => void router.push(spaceRoutes.home)}
- onPostSubmitted={() => void router.push(spaceRoutes.home)}
- onCreatePost={async (images, caption) => {
- await publishPost(images, caption);
- }}
+ onPostPhotoSelect={setPendingPostPhotoFiles}
onDeletePost={async (postId) => {
const spaceId = profile.spaceId;
if (!spaceId) throw new Error("Missing space.");
@@ -196,7 +195,6 @@ const Page: React.FC = () => {
onOpenProfilePhoto={() =>
void router.push(spaceRoutes.profilePhoto)
}
- onOpenSettings={() => void router.push(spaceRoutes.settings)}
onLoadPostImage={loadCurrentSpacePostAssetURL}
onSetPostLiked={async (postId, liked) => {
await setCurrentPostLiked(actorSpaceId, postId, liked);
diff --git a/web/apps/space/src/pages/app/settings.tsx b/web/apps/space/src/pages/app/settings.tsx
index 60285b03df..d7bb2c981b 100644
--- a/web/apps/space/src/pages/app/settings.tsx
+++ b/web/apps/space/src/pages/app/settings.tsx
@@ -32,7 +32,7 @@ const Page: React.FC = () => {
<>
<SpacePageMeta themeColor={spaceAppBackgroundColor} />
<SettingsScreen
- onBack={() => void router.push(spaceRoutes.profile)}
+ onBack={() => void router.push(spaceRoutes.home)}
onChangeCoverImage={() =>
void router.push(spaceRoutes.profileCoverFrom("settings"))
}
diff --git a/web/apps/space/src/screens/EditProfilePhotoScreen.tsx b/web/apps/space/src/screens/EditProfilePhotoScreen.tsx
index 0c9f992d80..2f6608a3b3 100644
--- a/web/apps/space/src/screens/EditProfilePhotoScreen.tsx
+++ b/web/apps/space/src/screens/EditProfilePhotoScreen.tsx
@@ -51,7 +51,7 @@ const EditProfilePhotoShell: React.FC<
background: spaceAppBackground,
color: textBase,
display: "grid",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
overflowX: "hidden",
placeItems: { xs: "stretch", sm: "start center" },
}}
@@ -62,7 +62,7 @@ const EditProfilePhotoShell: React.FC<
boxSizing: "border-box",
display: "flex",
flexDirection: "column",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
mx: "auto",
width: "100%",
"@media (min-width: 600px)": { maxWidth: 390 },
diff --git a/web/apps/space/src/screens/FriendsScreen.tsx b/web/apps/space/src/screens/FriendsScreen.tsx
index 88f2e911dd..08970ecc8f 100644
--- a/web/apps/space/src/screens/FriendsScreen.tsx
+++ b/web/apps/space/src/screens/FriendsScreen.tsx
@@ -1,7 +1,7 @@
import {
- ArrowLeft02Icon,
BubbleChatIcon,
Cancel01Icon,
+ HandPointingRightIcon,
MoreVerticalIcon,
Search01Icon,
UserAdd02Icon,
@@ -59,9 +59,9 @@ interface FriendsScreenProps {
onAcceptFriendRequest: (requestID: number) => Promise<void>;
onDeleteFriendRequest: (requestID: number) => Promise<void>;
onLoadFriendAvatar?: (friend: FriendProfile) => Promise<string | null>;
- onBack?: () => void;
onAddFriend: (username: string) => Promise<"friend" | "requested">;
onMessage?: (friendID: string) => void;
+ onPoke?: (friendID: string, requestID: string) => Promise<void>;
onOpenFriend?: (friendID: string) => void;
profileLink?: string;
username: string;
@@ -228,6 +228,7 @@ interface FriendRowProps {
friend: FriendProfile;
onLoadAvatar?: () => Promise<string | null | undefined>;
onMessage?: (friendID: string) => void;
+ onPoke?: (friendID: string, requestID: string) => Promise<void>;
onOpenFriend?: (friendID: string) => void;
onUnfriend?: (friendID: string) => void;
}
@@ -237,18 +238,50 @@ const FriendRow: React.FC<FriendRowProps> = ({
friend,
onLoadAvatar,
onMessage,
+ onPoke,
onOpenFriend,
onUnfriend,
}) => {
const [actionsAnchor, setActionsAnchor] = useState<HTMLElement | null>(
null,
);
+ const [pokePhase, setPokePhase] = useState<"busy" | "done">();
+ const [pokeFailed, setPokeFailed] = useState(false);
+ const pokeRequestID = React.useRef<string | undefined>(undefined);
+
+ React.useEffect(() => {
+ if (pokePhase != "done") return;
+
+ const timeoutID = window.setTimeout(() => {
+ setActionsAnchor(null);
+ }, spaceActionDoneDurationMs);
+
+ return () => window.clearTimeout(timeoutID);
+ }, [pokePhase]);
+
+ const poke = async () => {
+ if (!onPoke || pokePhase) return;
+ setPokePhase("busy");
+ setPokeFailed(false);
+ pokeRequestID.current ??= crypto.randomUUID();
+ try {
+ await onPoke(friend.id, pokeRequestID.current);
+ pokeRequestID.current = undefined;
+ setPokePhase("done");
+ } catch (error) {
+ log.error("Failed to send poke", error);
+ setPokeFailed(true);
+ setPokePhase(undefined);
+ }
+ };
const isActionsOpen = Boolean(actionsAnchor);
const actionsMenuID = `friend-actions-menu-${friend.id}`;
const actionsButtonID = `friend-actions-button-${friend.id}`;
const displayName = friend.fullName.trim() || friend.username.trim();
- const closeActions = () => setActionsAnchor(null);
+ const closeActions = () => {
+ setActionsAnchor(null);
+ };
const message = () => {
closeActions();
@@ -291,7 +324,10 @@ const FriendRow: React.FC<FriendRowProps> = ({
aria-controls={isActionsOpen ? actionsMenuID : undefined}
aria-expanded={isActionsOpen ? "true" : undefined}
aria-haspopup="menu"
- onClick={(event) => setActionsAnchor(event.currentTarget)}
+ onClick={(event) => {
+ if (pokePhase == "done") setPokePhase(undefined);
+ setActionsAnchor(event.currentTarget);
+ }}
sx={{
alignItems: "center",
bgcolor: "transparent",
@@ -378,6 +414,67 @@ const FriendRow: React.FC<FriendRowProps> = ({
</Box>
</MenuItem>
)}
+ {onPoke && (
+ <MenuItem
+ dense
+ disableRipple
+ onClick={() => void poke()}
+ disabled={pokePhase !== undefined}
+ sx={{
+ borderRadius: "10px",
+ color: textBase,
+ gap: "8px",
+ minHeight: 36,
+ px: "9px",
+ py: "4px",
+ whiteSpace: "nowrap",
+ "&.Mui-disabled": { color: textBase, opacity: 1 },
+ "&.Mui-focusVisible": {
+ bgcolor: "rgba(255, 255, 255, 0.08)",
+ },
+ "&:active": {
+ bgcolor: "rgba(255, 255, 255, 0.08)",
+ },
+ "&:hover": { bgcolor: "rgba(255, 255, 255, 0.08)" },
+ }}
+ >
+ <SpaceActionFeedbackIcon
+ phase={pokePhase ?? null}
+ size={18}
+ idleIcon={
+ <HugeiconsIcon
+ icon={HandPointingRightIcon}
+ size={18}
+ strokeWidth={1.8}
+ />
+ }
+ />
+ <Box
+ sx={{
+ fontFamily:
+ '"Inter Variable", Inter, sans-serif',
+ fontSize: 13,
+ fontWeight: 650,
+ lineHeight: "18px",
+ }}
+ >
+ {pokePhase == "done" ? "Poked" : "Poke"}
+ </Box>
+ </MenuItem>
+ )}
+ {pokeFailed && (
+ <Box
+ role="alert"
+ sx={{
+ color: textSoft,
+ fontSize: 12,
+ px: "9px",
+ py: "4px",
+ }}
+ >
+ Couldn&apos;t send poke. Try again.
+ </Box>
+ )}
<MenuItem
dense
disableRipple
@@ -616,8 +713,8 @@ export const FriendsScreen: React.FC<FriendsScreenProps> = ({
onAddFriend,
onDeleteFriendRequest,
onLoadFriendAvatar,
- onBack,
onMessage,
+ onPoke,
onOpenFriend,
profileLink,
username,
@@ -737,7 +834,7 @@ export const FriendsScreen: React.FC<FriendsScreenProps> = ({
color: textBase,
display: "grid",
boxSizing: "border-box",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
overflowX: "hidden",
placeItems: { xs: "stretch", sm: "start center" },
}}
@@ -747,7 +844,7 @@ export const FriendsScreen: React.FC<FriendsScreenProps> = ({
sx={{
bgcolor: "transparent",
boxSizing: "border-box",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
mx: "auto",
position: "relative",
width: "100%",
@@ -765,36 +862,7 @@ export const FriendsScreen: React.FC<FriendsScreenProps> = ({
width: "100%",
}}
>
- <Box
- component="button"
- type="button"
- aria-label="Back to profile"
- onClick={onBack}
- sx={{
- alignItems: "center",
- bgcolor: "transparent",
- border: 0,
- color: textBase,
- cursor: onBack ? "pointer" : "default",
- display: "flex",
- height: spaceTouchTargetSize,
- justifyContent: "flex-start",
- ml: "-2px",
- p: 0,
- width: spaceTouchTargetSize,
- "&:focus-visible": {
- borderRadius: "50%",
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- }}
- >
- <HugeiconsIcon
- icon={ArrowLeft02Icon}
- size={24}
- strokeWidth={1.8}
- />
- </Box>
+ <Box aria-hidden />
<Box
component="h1"
sx={{
@@ -888,12 +956,12 @@ export const FriendsScreen: React.FC<FriendsScreenProps> = ({
component="input"
type="text"
inputMode="search"
- aria-label="Search friends"
+ aria-label="Search your friends"
autoComplete="off"
onChange={(event) =>
setSearchQuery(event.target.value)
}
- placeholder="Search"
+ placeholder="Search your friends"
value={searchQuery}
sx={{
bgcolor: "transparent",
@@ -987,6 +1055,7 @@ export const FriendsScreen: React.FC<FriendsScreenProps> = ({
loadFriendAvatar(friend)
}
onMessage={onMessage}
+ onPoke={onPoke}
onOpenFriend={onOpenFriend}
onUnfriend={() => {
setUnfriendErrorMessage(null);
@@ -1005,7 +1074,8 @@ export const FriendsScreen: React.FC<FriendsScreenProps> = ({
'"Inter Variable", Inter, sans-serif',
fontSize: 14,
lineHeight: "20px",
- minHeight: "max(0px, calc(100svh - 116px))",
+ minHeight:
+ "max(0px, calc(var(--space-page-height, 100svh) - 116px))",
placeItems: "center",
textAlign: "center",
}}
diff --git a/web/apps/space/src/screens/HomeScreen.tsx b/web/apps/space/src/screens/HomeScreen.tsx
index a6a71af4bc..b8e8cb80a7 100644
--- a/web/apps/space/src/screens/HomeScreen.tsx
+++ b/web/apps/space/src/screens/HomeScreen.tsx
@@ -14,7 +14,6 @@ import {
focusFeedPost,
registerFeedPost,
} from "components/feed-video-playback";
-import { SpaceFeedPostButton } from "components/FeedPostButton";
import {
SpaceFileViewer,
type SpaceViewerPhoto,
@@ -30,7 +29,6 @@ import {
} from "components/post-like-animation";
import { SpacePostAvatar } from "components/PostAvatar";
import { SpacePostGrid } from "components/PostGrid";
-import { SpacePostPhotoInput } from "components/PostPhotoInput";
import { SpacePostPhotosCounter } from "components/PostPhotosCounter";
import { SpacePostPhotosDots } from "components/PostPhotosDots";
import { SpacePostTile } from "components/PostTile";
@@ -109,17 +107,13 @@ interface HomeScreenProps {
friendRequestSentToastName?: string;
hasFeedLoadMoreError?: boolean;
hasMoreFeedItems?: boolean;
- hasUnreadMessages?: boolean;
isFeedLoading?: boolean;
- isFeedComplete?: boolean;
isFeedLoadingMore?: boolean;
localFeedPosts?: LocalSpaceFeedPost[];
feedSession?: SpaceFeedSession;
- showFirstPostPrompt?: boolean;
showInstallPrompt?: boolean;
showInviteFriendsToast?: boolean;
onAddFriend: () => void;
- onPostPhotoSelect: (files: File[]) => void;
onRetryPost?: (localPostId: string) => Promise<void>;
onDeletePost?: (postId: number) => Promise<void> | void;
onLoadMoreFeedItems?: () => Promise<void> | void;
@@ -128,7 +122,6 @@ interface HomeScreenProps {
onFriendRequestSentToastClose?: () => void;
onInviteFriendsToastClose?: () => void;
onOpenFriend?: (friendID: string, username?: string) => void;
- onOpenMessages?: () => void;
onOpenProfile?: () => void;
onReplyToPost?: (
postSpaceId: string,
@@ -1482,7 +1475,6 @@ const FeedItem: React.FC<FeedItemProps> = ({
}}
>
<SpacePostAvatar
- outerRing
ready={isAvatarReady}
size={feedAvatarSize}
src={displayAvatarUrl}
@@ -1728,7 +1720,7 @@ const AddedFriendToast: React.FC<AddedFriendToastProps> = ({
px: feedHorizontalPadding,
pointerEvents: "none",
position: "fixed",
- top: "calc(env(safe-area-inset-top) + 12px)",
+ top: "calc(env(safe-area-inset-top) + 8px)",
transform: "translateX(-50%)",
width: "100%",
zIndex: 20,
@@ -1741,7 +1733,7 @@ const AddedFriendToast: React.FC<AddedFriendToastProps> = ({
sx={{
alignItems: "center",
bgcolor: spaceHomeSurface,
- borderRadius: "24px",
+ borderRadius: "32px",
boxShadow: "0 12px 32px rgba(0, 0, 0, 0.18)",
boxSizing: "border-box",
color: textBase,
@@ -1846,17 +1838,13 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
friendRequestSentToastName,
hasFeedLoadMoreError = false,
hasMoreFeedItems = false,
- hasUnreadMessages,
isFeedLoading = false,
- isFeedComplete = false,
isFeedLoadingMore = false,
localFeedPosts = [],
feedSession,
- showFirstPostPrompt = false,
showInstallPrompt = false,
showInviteFriendsToast = false,
onAddFriend,
- onPostPhotoSelect,
onRetryPost,
onDeletePost,
onLoadMoreFeedItems,
@@ -1865,7 +1853,6 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
onFriendRequestSentToastClose,
onInviteFriendsToastClose,
onOpenFriend,
- onOpenMessages,
onOpenProfile,
onReplyToPost,
onSetPostLiked,
@@ -1890,7 +1877,6 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
Record<string, true>
>({});
const newestLocalPostID = localFeedPosts[0]?.id;
- const postInputRef = React.useRef<HTMLInputElement | null>(null);
const feedLoadMoreRef = React.useRef<HTMLDivElement | null>(null);
const feedAvatarLoadsInFlightRef = React.useRef<
Map<string, Promise<string | null>>
@@ -1918,10 +1904,6 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
!friendRequestSentToastName &&
!showInviteFriendsToast &&
!selectedViewer;
- const showUnreadIndicator = hasUnreadMessages === true;
- const openPostPhotoPicker = () => {
- postInputRef.current?.click();
- };
const openFeedPhoto = (
post: SpacePost,
photo: SpaceViewerPhoto,
@@ -2238,8 +2220,8 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
bgcolor: homeBackground,
color: textBase,
display: "grid",
- minHeight: "100svh",
- overflowX: "hidden",
+ minHeight: "var(--space-page-height, 100svh)",
+ overflowX: "clip",
placeItems: { xs: "stretch", sm: "start center" },
position: "relative",
}}
@@ -2255,25 +2237,15 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
bgcolor: homeBackground,
boxSizing: "border-box",
maxWidth: "100%",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
minWidth: 0,
mx: "auto",
- overflowX: "hidden",
+ overflowX: "clip",
width: "100%",
"@media (min-width: 600px)": { maxWidth: 390 },
}}
>
- <SpaceHomeHeader
- profile={profile}
- showUnreadIndicator={showUnreadIndicator}
- onOpenMessages={onOpenMessages}
- onOpenProfile={onOpenProfile}
- >
- <SpacePostPhotoInput
- inputRef={postInputRef}
- onSelect={onPostPhotoSelect}
- />
- </SpaceHomeHeader>
+ <SpaceHomeHeader />
<Box
component="section"
id="space-main-content"
@@ -2285,11 +2257,12 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
flexDirection: "column",
gap: 0,
justifyContent: showFeedCards ? "flex-start" : "center",
- minHeight: "calc(100svh - 68px)",
+ minHeight:
+ "calc(var(--space-page-height, 100svh) - 60px)",
minWidth: 0,
- pb: "calc(env(safe-area-inset-bottom) + 112px)",
+ pb: showFeedCards ? "24px" : "12px",
px: feedHorizontalPadding,
- pt: showFeedCards ? 0 : "8px",
+ pt: showFeedCards ? 0 : "4px",
width: "100%",
}}
>
@@ -2314,10 +2287,8 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
<>
<SpacePostGrid
postCount={
- isFeedComplete
- ? latestFeedEntries.length +
- gridFeedItems.length
- : undefined
+ latestFeedEntries.length +
+ gridFeedItems.length
}
items={gridFeedItems.map((item) => {
const photo = spacePostPhotos(item)[0]!;
@@ -2498,7 +2469,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
color: "#FFFFFF",
display: "flex",
flexDirection: "column",
- height: "calc(100svh - 184px - env(safe-area-inset-bottom))",
+ height: "calc(var(--space-page-height, 100svh) - 76px)",
minHeight: 360,
overflow: "hidden",
px: "24px",
@@ -2569,7 +2540,7 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
size={18}
strokeWidth={1.8}
/>
- Add friend
+ Add friends
</Box>
<Box sx={{ flexGrow: 1, minHeight: "32px" }} />
<Box
@@ -2591,10 +2562,6 @@ export const HomeScreen: React.FC<HomeScreenProps> = ({
</Box>
)}
</Box>
- <SpaceFeedPostButton
- onClick={openPostPhotoPicker}
- showFirstPostPrompt={showFirstPostPrompt}
- />
{selectedViewer && (
<SpaceFileViewer
closeOnSwipePastEnd
diff --git a/web/apps/space/src/screens/MessagesScreen.tsx b/web/apps/space/src/screens/MessagesScreen.tsx
index 7f54111f01..1524c44d13 100644
--- a/web/apps/space/src/screens/MessagesScreen.tsx
+++ b/web/apps/space/src/screens/MessagesScreen.tsx
@@ -3,7 +3,6 @@ import {
ArrowLeft02Icon,
Cancel01Icon,
FavouriteIcon,
- HandPointingRightIcon,
ImageDelete02Icon,
Navigation03Icon,
} from "@hugeicons/core-free-icons";
@@ -19,23 +18,25 @@ import {
useMediaQuery,
} from "@mui/material";
import { SpaceActionToast } from "components/ActionToast";
-import { SpaceAvatarImage } from "components/AvatarImage";
+import {
+ SpaceActivityAvatar as Avatar,
+ SpaceActivityIdentity,
+} from "components/ActivityList";
import { SpaceLiveStatus } from "components/LiveStatus";
import {
MessageQuickReactions,
MessageReactionPicker,
} from "components/MessageReactionPicker";
import { SpaceMessageText } from "components/MessageText";
-import { SpacePostPhotoInput } from "components/PostPhotoInput";
import {
SpacePostPhotosBadge,
SpacePostVideoBadge,
} from "components/PostPhotosBadge";
+import { SpacePostPreviewThumbnail } from "components/PostPreviewThumbnail";
import { SpaceLoadingSpinner } from "components/RouteFallback";
import { SpaceShareInviteButton } from "components/ShareInviteButton";
import { SpaceSkipLink } from "components/SkipLink";
import { emojiName } from "data/emojis";
-import { formatTimeAgo } from "ente-base/date";
import log from "ente-base/log";
import React from "react";
import { flushSync } from "react-dom";
@@ -46,6 +47,11 @@ import type {
SpaceMessageConversation,
SpaceMessageQuote,
} from "services/space";
+import {
+ spaceActivityListSx,
+ spaceActivityPreviewSx,
+ spaceActivityRowSx,
+} from "styles/activity-list";
import {
spaceAppBackground,
spaceAppBackgroundColor,
@@ -67,12 +73,12 @@ import { postQuoteErrorState, postQuoteKey } from "utils/post-quote";
const green = "#08C225";
const textBase = spaceText;
const textSecondary = spaceTextMuted;
-const conversationPrimaryText = spaceText;
const composerSurface = spaceSurface;
const outgoingBubble = "#176B2A";
const incomingBubble = spaceSurface;
const outgoingMessageText = "#FFFFFF";
const incomingMessageText = spaceText;
+const conversationPrimaryText = spaceText;
const outgoingQuoteBubble = "#213425";
const incomingQuoteBubble = spaceSurfaceHover;
const incomingQuoteText = spaceTextMuted;
@@ -93,23 +99,6 @@ const messageLongPressMoveTolerancePx = 10;
const messageReplySwipeThresholdPx = 64;
const messageReplySwipeMinThresholdPx = 20;
const messageActionsTouchOpenMouseSuppressMs = 900;
-const dayMs = 24 * 60 * 60 * 1000;
-const shouldShowPostSomething = (
- conversation: SpaceMessageConversation,
- latestPostCreatedAtMs: number | null | undefined,
-) => {
- const activity = conversation.latestActivity;
- return (
- latestPostCreatedAtMs !== undefined &&
- (latestPostCreatedAtMs === null ||
- latestPostCreatedAtMs < activity.createdAtMs) &&
- (activity.type == "message" || activity.type == "post_reply") &&
- !activity.outgoing &&
- !activity.isUnavailable &&
- activity.kind == "poke"
- );
-};
-
interface MessagesScreenProps {
conversations: SpaceMessageConversation[];
friendsCount?: number;
@@ -117,23 +106,14 @@ interface MessagesScreenProps {
isThreadLoading?: boolean;
isThreadReadOnly?: boolean;
isThreadRecipientLoading?: boolean;
- latestPostCreatedAtMs?: number | null;
messages: SpaceMessage[];
- onBack?: () => void;
onCloseThread: () => void;
- onConfirmFriendRequest: (
- conversation: SpaceMessageConversation,
- ) => Promise<void>;
onDeleteMessage: (messageId: string) => Promise<void>;
- onDeleteFriendRequest: (
- conversation: SpaceMessageConversation,
- ) => Promise<void>;
onOpenSelectedFriendProfile: (
friend: SpaceMessageConversation["friend"],
) => void;
onOpenQuotePost: (quote: SpaceMessageQuote) => void;
onOpenThread: (conversation: SpaceMessageConversation) => void;
- onPostPhotoSelect: (files: File[]) => void;
onLoadActivityPost?: (
post: SpaceMessageActivityPost,
) => Promise<SpaceMessageActivityPost | undefined>;
@@ -142,14 +122,12 @@ interface MessagesScreenProps {
messageId: string,
text: string,
) => Promise<void>;
- onSendPoke: (spaceId: string) => Promise<void>;
onSendMessage: (spaceId: string, text: string) => Promise<void>;
onSetMessageReaction: (
messageId: string,
emoji: string | undefined,
) => Promise<void>;
profileLink?: string;
- newConversationIds?: string[];
profile: SetupProfile;
selectedFriend?: SpaceMessageConversation["friend"];
threadBackLabel?: string;
@@ -164,13 +142,6 @@ interface MessageContextMenuState {
type MessageActionsOpenSource = "button" | "contextmenu" | "touch";
-interface ConversationSection {
- items: SpaceMessageConversation[];
- title: string;
-}
-
-const microsForTimestamp = (timestampMs: number) => timestampMs * 1000;
-
const resizeComposer = (input: HTMLTextAreaElement | null) => {
if (!input) return;
@@ -189,26 +160,6 @@ const copyTextToClipboard = async (text: string) => {
await navigator.clipboard.writeText(text);
};
-const Avatar: React.FC<{ avatarUrl?: string | null; size: number }> = ({
- avatarUrl,
- size,
-}) => (
- <Box
- sx={{
- alignItems: "center",
- borderRadius: "50%",
- display: "flex",
- flexShrink: 0,
- height: size,
- justifyContent: "center",
- overflow: "hidden",
- width: size,
- }}
- >
- <SpaceAvatarImage src={avatarUrl} />
- </Box>
-);
-
const truncateMessageText = (text: string): string => {
const lines = text.split("\n");
const firstLine = lines[0] ?? text;
@@ -238,16 +189,7 @@ const conversationPreview = (conversation: SpaceMessageConversation) => {
const activity = conversation.latestActivity;
if (activity.isUnavailable) return "Message unavailable";
if (activity.type == "empty") {
- return "You're now friends. Say hello!";
- }
- if (activity.type == "friend_request") {
- return "Sent you a friend request";
- }
- if (activity.type == "friend_added") {
- return "You're now friends. Say hello!";
- }
- if (activity.type == "post_like") {
- return activity.outgoing ? "You liked a post" : "Liked your post";
+ return "No messages yet";
}
const text = activity.text ? truncateMessageText(activity.text) : "";
if (activity.type == "post_reply") {
@@ -281,17 +223,7 @@ const ConversationPreviewLine: React.FC<{
conversation: SpaceMessageConversation;
}> = ({ conversation }) => {
const activity = conversation.latestActivity;
- const previewLineSx = {
- color: textSecondary,
- fontFamily: '"Inter Variable", Inter, sans-serif',
- fontSize: 13,
- fontWeight: 500,
- lineHeight: "18px",
- minWidth: 0,
- overflow: "hidden",
- textOverflow: "ellipsis",
- whiteSpace: "nowrap",
- };
+ const previewLineSx = spaceActivityPreviewSx;
if (activity.type == "message_like" && activity.text) {
return (
@@ -320,65 +252,7 @@ const ConversationPreviewLine: React.FC<{
};
const conversationId = (conversation: SpaceMessageConversation) =>
- conversation.latestActivity.type == "friend_request"
- ? conversation.latestActivity.id
- : (conversation.friend.spaceId ?? conversation.friend.id);
-
-const conversationTimeSections = (
- conversations: SpaceMessageConversation[],
- newConversationIds: string[],
-) => {
- const newIds = new Set(newConversationIds);
- const now = Date.now();
- const today = new Date(now);
- const startOfTodayMs = new Date(
- today.getFullYear(),
- today.getMonth(),
- today.getDate(),
- ).getTime();
- const startOfYesterdayMs = new Date(
- today.getFullYear(),
- today.getMonth(),
- today.getDate() - 1,
- ).getTime();
- const sections: ConversationSection[] = [
- { title: "New", items: [] },
- { title: "Today", items: [] },
- { title: "Yesterday", items: [] },
- { title: "Last 7 days", items: [] },
- { title: "Last 30 days", items: [] },
- { title: "Older", items: [] },
- ];
-
- for (const conversation of conversations) {
- if (newIds.has(conversationId(conversation))) {
- sections[0]!.items.push(conversation);
- continue;
- }
-
- const activity = conversation.latestActivity;
- if (activity.createdAtMs >= startOfTodayMs) {
- sections[1]!.items.push(conversation);
- continue;
- }
- if (activity.createdAtMs >= startOfYesterdayMs) {
- sections[2]!.items.push(conversation);
- continue;
- }
-
- const ageMs = Math.max(0, now - activity.createdAtMs);
- if (ageMs <= 7 * dayMs) {
- sections[3]!.items.push(conversation);
- continue;
- }
- if (ageMs <= 30 * dayMs) {
- sections[4]!.items.push(conversation);
- continue;
- }
- sections[5]!.items.push(conversation);
- }
- return sections;
-};
+ conversation.friend.spaceId ?? conversation.friend.id;
const conversationUnreadLabel = (count: number) =>
count > 99 ? "99+" : String(count);
@@ -460,47 +334,21 @@ const MessageTimeSeparator: React.FC<{ timestampMs: number }> = ({
const ConversationListItem: React.FC<{
activityPost?: SpaceMessageActivityPost;
conversation: SpaceMessageConversation;
- latestPostCreatedAtMs?: number | null;
- onConfirmFriendRequest: (
- conversation: SpaceMessageConversation,
- ) => Promise<void>;
- onDeleteFriendRequest: (
- conversation: SpaceMessageConversation,
- ) => Promise<void>;
onLoadActivityPost?: (post: SpaceMessageActivityPost) => void;
onOpenFriendProfile: (friend: SpaceMessageConversation["friend"]) => void;
onOpenThread: (conversation: SpaceMessageConversation) => void;
- onPostSomething: () => void;
}> = ({
activityPost,
conversation,
- latestPostCreatedAtMs,
- onConfirmFriendRequest,
- onDeleteFriendRequest,
onLoadActivityPost,
onOpenFriendProfile,
onOpenThread,
- onPostSomething,
}) => {
const name =
conversation.friend.fullName.trim() || conversation.friend.username;
- const timestampLabel = formatTimeAgo(
- microsForTimestamp(conversation.latestActivity.createdAtMs),
- );
- const isFriendRequest =
- conversation.latestActivity.type == "friend_request";
const post = conversation.latestActivity.post;
- const postThumbnailUrl = (activityPost ?? post)?.imageUrl;
const showPostThumbnailSlot = Boolean(post);
- const isPostThumbnailUnavailable = Boolean(
- (activityPost ?? post)?.isUnavailable,
- );
- const hasPostThumbnailLoadError = Boolean(activityPost?.hasLoadError);
const unreadCount = conversation.unreadCount;
- const showPostSomething = shouldShowPostSomething(
- conversation,
- latestPostCreatedAtMs,
- );
React.useEffect(() => {
if (!post || post.isUnavailable || post.imageUrl || activityPost) {
return;
@@ -513,39 +361,13 @@ const ConversationListItem: React.FC<{
post?.imageUrl,
post?.isUnavailable,
]);
- const confirmFriendRequest = () => {
- void onConfirmFriendRequest(conversation).catch((error: unknown) =>
- log.error("Failed to confirm friend request", error),
- );
- };
- const deleteFriendRequest = () => {
- void onDeleteFriendRequest(conversation).catch((error: unknown) =>
- log.error("Failed to delete friend request", error),
- );
- };
return (
<Box component="li" sx={{ listStyle: "none" }}>
<Box
sx={{
- alignItems: "center",
- borderRadius: "8px",
- boxSizing: "border-box",
- color: conversationPrimaryText,
- display: "grid",
- gap: "10px",
- gridTemplateColumns:
- isFriendRequest || showPostSomething
- ? "44px minmax(0, 1fr) auto"
- : "44px minmax(0, 1fr)",
- minHeight: 64,
- mx: "-8px",
- p: "8px",
- textAlign: "left",
- transition: "background-color 140ms ease",
- width: "calc(100% + 16px)",
- "&:active": { bgcolor: spaceSurface },
- "&:hover": { bgcolor: spaceSurface },
+ ...spaceActivityRowSx,
+ gridTemplateColumns: "44px minmax(0, 1fr)",
"&:has(> [data-space-row-action]:active)": {
bgcolor: "transparent",
},
@@ -562,42 +384,33 @@ const ConversationListItem: React.FC<{
width: 44,
}}
>
- {isFriendRequest ? (
+ <Box
+ component="button"
+ type="button"
+ aria-label={`Open ${name}'s profile`}
+ onClick={() => onOpenFriendProfile(conversation.friend)}
+ sx={{
+ appearance: "none",
+ bgcolor: "transparent",
+ border: 0,
+ borderRadius: "50%",
+ cursor: "pointer",
+ display: "block",
+ height: 44,
+ p: 0,
+ width: 44,
+ "&:focus-visible": {
+ outline: `2px solid ${green}`,
+ outlineOffset: 2,
+ },
+ }}
+ >
<Avatar
avatarUrl={conversation.friend.avatarUrl}
size={44}
/>
- ) : (
- <Box
- component="button"
- type="button"
- aria-label={`Open ${name}'s profile`}
- onClick={() =>
- onOpenFriendProfile(conversation.friend)
- }
- sx={{
- appearance: "none",
- bgcolor: "transparent",
- border: 0,
- borderRadius: "50%",
- cursor: "pointer",
- display: "block",
- height: 44,
- p: 0,
- width: 44,
- "&:focus-visible": {
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- }}
- >
- <Avatar
- avatarUrl={conversation.friend.avatarUrl}
- size={44}
- />
- </Box>
- )}
- {unreadCount > 0 && !isFriendRequest && (
+ </Box>
+ {unreadCount > 0 && (
<Box
aria-label={`${unreadCount} unread update${unreadCount == 1 ? "" : "s"}`}
component="span"
@@ -630,32 +443,20 @@ const ConversationListItem: React.FC<{
)}
</Box>
<Box
- component={isFriendRequest ? "div" : "button"}
- type={isFriendRequest ? undefined : "button"}
- aria-label={
- isFriendRequest
- ? undefined
- : `Open conversation with ${name}`
- }
- onClick={
- isFriendRequest
- ? undefined
- : () => onOpenThread(conversation)
- }
+ component="button"
+ type="button"
+ aria-label={`Open conversation with ${name}`}
+ onClick={() => onOpenThread(conversation)}
sx={{
alignItems: "center",
appearance: "none",
bgcolor: "transparent",
border: 0,
color: "inherit",
- cursor: isFriendRequest ? "default" : "pointer",
+ cursor: "pointer",
display: "grid",
gap: "10px",
- gridColumn: isFriendRequest
- ? undefined
- : showPostSomething
- ? "2"
- : "2 / -1",
+ gridColumn: "2 / -1",
gridTemplateColumns: showPostThumbnailSlot
? "minmax(0, 1fr) 44px"
: "minmax(0, 1fr)",
@@ -671,283 +472,20 @@ const ConversationListItem: React.FC<{
}}
>
<Box sx={{ minWidth: 0 }}>
- <Box
- sx={{
- alignItems: "center",
- display: "flex",
- gap: "4px",
- minWidth: 0,
- }}
- >
- <Box
- sx={{
- flex: "0 1 auto",
- fontFamily:
- '"Inter Variable", Inter, sans-serif',
- fontSize: 14,
- fontWeight: 700,
- lineHeight: "20px",
- minWidth: 0,
- overflow: "hidden",
- textOverflow: "ellipsis",
- whiteSpace: "nowrap",
- }}
- >
- {isFriendRequest
- ? `@${conversation.friend.username}`
- : firstNameFrom(name)}
- </Box>
- <Box
- aria-hidden
- component="span"
- sx={{
- color: textSecondary,
- flexShrink: 0,
- fontFamily:
- '"Inter Variable", Inter, sans-serif',
- fontSize: 12,
- fontWeight: 600,
- lineHeight: "16px",
- }}
- >
- &middot;
- </Box>
- <Box
- component="time"
- dateTime={new Date(
- conversation.latestActivity.createdAtMs,
- ).toISOString()}
- sx={{
- color: textSecondary,
- flexShrink: 0,
- fontFamily:
- '"Inter Variable", Inter, sans-serif',
- fontSize: 12,
- fontWeight: 600,
- lineHeight: "16px",
- whiteSpace: "nowrap",
- }}
- >
- {timestampLabel}
- </Box>
- </Box>
+ <SpaceActivityIdentity
+ name={firstNameFrom(name)}
+ createdAtMs={
+ conversation.latestActivity.createdAtMs
+ }
+ />
<ConversationPreviewLine conversation={conversation} />
</Box>
- {showPostThumbnailSlot &&
- (postThumbnailUrl ? (
- <Box
- sx={{
- position: "relative",
- width: 44,
- height: 44,
- }}
- >
- <Box
- component="img"
- alt=""
- src={postThumbnailUrl}
- sx={{
- borderRadius: "20%",
- display: "block",
- height: "100%",
- objectFit: "cover",
- objectPosition: "center",
- width: "100%",
- }}
- />
- <SpacePostVideoBadge
- durationMs={
- (activityPost ?? post)?.durationMs
- }
- />
- </Box>
- ) : (
- <Box
- aria-label={
- isPostThumbnailUnavailable
- ? "Post image unavailable"
- : hasPostThumbnailLoadError
- ? "Couldn't load post image"
- : "Loading post image"
- }
- role="img"
- sx={{
- alignItems: "center",
- bgcolor: incomingQuoteBubble,
- borderRadius: "20%",
- color: incomingQuoteText,
- display: "flex",
- height: 44,
- justifyContent: "center",
- width: 44,
- }}
- >
- {isPostThumbnailUnavailable && (
- <HugeiconsIcon
- icon={ImageDelete02Icon}
- size={18}
- strokeWidth={1.5}
- />
- )}
- </Box>
- ))}
+ {showPostThumbnailSlot && (
+ <SpacePostPreviewThumbnail
+ post={activityPost ?? post}
+ />
+ )}
</Box>
- {showPostSomething && (
- <Box
- className="green-bg"
- component="button"
- type="button"
- data-space-row-action
- onClick={onPostSomething}
- sx={{
- bgcolor: green,
- border: 0,
- borderRadius: "16px",
- color: spaceOnAccent,
- cursor: "pointer",
- fontFamily: '"Inter Variable", Inter, sans-serif',
- fontSize: 12,
- fontWeight: 700,
- height: 36,
- px: "12px",
- whiteSpace: "nowrap",
- "&:focus-visible": {
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- "&:hover": { bgcolor: "#07A820" },
- }}
- >
- Post a photo
- </Box>
- )}
- {isFriendRequest && (
- <Box
- data-space-row-action
- sx={{ display: "flex", flexShrink: 0, gap: "6px" }}
- >
- <Box
- className="green-bg"
- component="button"
- type="button"
- onClick={confirmFriendRequest}
- sx={{
- bgcolor: green,
- border: 0,
- borderRadius: "12px",
- color: spaceOnAccent,
- cursor: "pointer",
- fontFamily:
- '"Inter Variable", Inter, sans-serif',
- fontSize: 12,
- fontWeight: 700,
- height: 34,
- px: "12px",
- "&:hover": { bgcolor: "#07A820" },
- }}
- >
- Accept
- </Box>
- <Box
- component="button"
- type="button"
- aria-label={`Dismiss friend request from ${name}`}
- onClick={deleteFriendRequest}
- sx={{
- alignItems: "center",
- bgcolor: "transparent",
- border: 0,
- borderRadius: "50%",
- color: textBase,
- cursor: "pointer",
- display: "flex",
- height: 34,
- justifyContent: "center",
- p: 0,
- width: 34,
- "&:hover": { bgcolor: spaceSurfaceHover },
- }}
- >
- <HugeiconsIcon
- icon={Cancel01Icon}
- size={18}
- strokeWidth={2}
- />
- </Box>
- </Box>
- )}
- </Box>
- </Box>
- );
-};
-
-const ConversationSection: React.FC<{
- activityPostsByKey: Record<string, SpaceMessageActivityPost>;
- latestPostCreatedAtMs?: number | null;
- onConfirmFriendRequest: (
- conversation: SpaceMessageConversation,
- ) => Promise<void>;
- onDeleteFriendRequest: (
- conversation: SpaceMessageConversation,
- ) => Promise<void>;
- onLoadActivityPost?: (post: SpaceMessageActivityPost) => void;
- onOpenFriendProfile: (friend: SpaceMessageConversation["friend"]) => void;
- onOpenThread: (conversation: SpaceMessageConversation) => void;
- onPostSomething: () => void;
- section: ConversationSection;
-}> = ({
- activityPostsByKey,
- latestPostCreatedAtMs,
- onConfirmFriendRequest,
- onDeleteFriendRequest,
- onLoadActivityPost,
- onOpenFriendProfile,
- onOpenThread,
- onPostSomething,
- section,
-}) => {
- if (section.items.length == 0) return null;
-
- return (
- <Box component="section" sx={{ mb: "10px" }}>
- <Box
- component="h2"
- sx={{
- color: textSecondary,
- fontFamily: '"Inter Variable", Inter, sans-serif',
- fontSize: 13,
- fontWeight: 700,
- lineHeight: "18px",
- m: 0,
- pb: "4px",
- pt: "12px",
- }}
- >
- {section.title}
- </Box>
- <Box component="ul" sx={{ listStyle: "none", m: 0, p: 0 }}>
- {section.items.map((conversation) => (
- <ConversationListItem
- key={conversationId(conversation)}
- activityPost={
- conversation.latestActivity.post
- ? activityPostsByKey[
- postQuoteKey(
- conversation.latestActivity.post,
- )
- ]
- : undefined
- }
- conversation={conversation}
- latestPostCreatedAtMs={latestPostCreatedAtMs}
- onConfirmFriendRequest={onConfirmFriendRequest}
- onDeleteFriendRequest={onDeleteFriendRequest}
- onLoadActivityPost={onLoadActivityPost}
- onOpenFriendProfile={onOpenFriendProfile}
- onOpenThread={onOpenThread}
- onPostSomething={onPostSomething}
- />
- ))}
</Box>
</Box>
);
@@ -965,7 +503,7 @@ const bodyBubblesCanGroup = (
if (!first || !second) return false;
if (!sameMessageSender(first, second)) return false;
if (first.reaction) return false;
- if (first.kind == "post_like" || first.kind == "friend_added") return false;
+ if (first.kind == "friend_added") return false;
if (
(second.kind != "regular" && second.kind != "poke") ||
second.replyMessageId
@@ -1538,24 +1076,19 @@ const MessageBubble: React.FC<{
const bubbleBorderRadius = isOwn
? `20px ${groupsWithPrevious ? "6px" : "20px"} ${groupsWithNext ? "6px" : "20px"} 20px`
: `${groupsWithPrevious ? "6px" : "20px"} 20px 20px ${groupsWithNext ? "6px" : "20px"}`;
- const isSyntheticPostLike = !isUnavailable && message.kind == "post_like";
const isFriendAdded = !isUnavailable && message.kind == "friend_added";
const isPostReply = !isUnavailable && message.kind == "post_reply";
- const isSystemMessage = isSyntheticPostLike || isFriendAdded;
+ const isSystemMessage = isFriendAdded;
const hasMessageReply = !isUnavailable && Boolean(message.replyMessageId);
- const actionLabel = isSyntheticPostLike
+ const actionLabel = isPostReply
? isOwn
- ? "You liked a post"
- : "Liked your post"
- : isPostReply
+ ? "You replied to a post"
+ : "Replied to your post"
+ : hasMessageReply
? isOwn
- ? "You replied to a post"
- : "Replied to your post"
- : hasMessageReply
- ? isOwn
- ? "You replied"
- : "Replied to you"
- : undefined;
+ ? "You replied"
+ : "Replied to you"
+ : undefined;
const hasBodyBubble = !isSystemMessage;
const hasActionsTrigger = canOpenActions && !isUnavailable;
const rowAlignItems = isFriendAdded
@@ -1814,7 +1347,7 @@ const MessageBubble: React.FC<{
>
{actionLabel && (
<MessageActionLabel
- icon={isSyntheticPostLike ? "like" : "reply"}
+ icon="reply"
isOwn={isOwn}
label={actionLabel}
/>
@@ -1827,7 +1360,7 @@ const MessageBubble: React.FC<{
profile={profile}
/>
)}
- {(isPostReply || isSyntheticPostLike) && (
+ {isPostReply && (
<PostQuotePreview
activityPost={activityPost}
isOwn={isOwn}
@@ -2013,21 +1546,14 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
isThreadLoading = false,
isThreadReadOnly = false,
isThreadRecipientLoading = false,
- latestPostCreatedAtMs,
messages,
- newConversationIds = [],
- onBack,
onCloseThread,
- onConfirmFriendRequest,
onDeleteMessage,
- onDeleteFriendRequest,
onOpenSelectedFriendProfile,
onOpenQuotePost,
onOpenThread,
- onPostPhotoSelect,
onLoadActivityPost,
onReplyToMessage,
- onSendPoke,
onSendMessage,
onSetMessageReaction,
profile,
@@ -2054,7 +1580,6 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
Record<string, SpaceMessageActivityPost>
>({});
const composerRef = React.useRef<HTMLTextAreaElement | null>(null);
- const postPhotoInputRef = React.useRef<HTMLInputElement | null>(null);
const threadScrollRef = React.useRef<HTMLDivElement | null>(null);
const stickToThreadBottomRef = React.useRef(true);
const smoothNextMessageScrollRef = React.useRef(false);
@@ -2075,7 +1600,6 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
isThreadOpen && !isThreadReadOnly && !isThreadRecipientLoading;
const canSend =
canInteract && messageText.trim().length > 0 && sendPhase == "idle";
- const canPoke = canInteract && sendPhase == "idle";
const selectedName = selectedFriend
? selectedFriend.fullName.trim() || selectedFriend.username
: "";
@@ -2087,12 +1611,8 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
const showInviteEmptyState = friendsCount == 0 && Boolean(profileLink);
const emptyConversationsCopy =
friendsCount == 0
- ? "No messages yet. Once you add friends, you'll see their likes, replies, pokes and messages here."
- : "No messages yet. You'll see your friends' likes, replies, pokes and messages here.";
- const conversationSections = React.useMemo(
- () => conversationTimeSections(conversations, newConversationIds),
- [conversations, newConversationIds],
- );
+ ? "No messages yet. Once you add friends, you'll see their replies and messages here."
+ : "No messages yet. You'll see your friends' replies and messages here.";
const previewGenerationRef = React.useRef(0);
React.useEffect(() => {
const cancelPreviewLoads = () => {
@@ -2201,8 +1721,6 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
messageActionsAnchor instanceof HTMLElement &&
messageActionsAnchor.hasAttribute("data-message-bubble");
- const openPostPhotoPicker = () => postPhotoInputRef.current?.click();
-
const sendMessage = () => {
const text = messageText.trim();
if (!selectedFriend || !canInteract || !canSend) return;
@@ -2236,21 +1754,6 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
});
};
- const sendPoke = () => {
- if (!selectedFriend || !canPoke) return;
- const spaceId = selectedFriend.spaceId ?? selectedFriend.id;
- stickToThreadBottomRef.current = true;
- smoothNextMessageScrollRef.current = true;
- setSendPhase("sending");
- void onSendPoke(spaceId)
- .then(() => setSendPhase("idle"))
- .catch((error: unknown) => {
- smoothNextMessageScrollRef.current = false;
- log.error("Failed to send poke", error);
- setSendPhase("idle");
- });
- };
-
const canOpenMessageActions = (message: SpaceMessage) =>
message.kind != "poke" ||
(canInteract && isCurrentProfileMessage(message, profile));
@@ -2575,18 +2078,18 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
zIndex={1600}
/>
)}
- <SpacePostPhotoInput
- inputRef={postPhotoInputRef}
- onSelect={onPostPhotoSelect}
- />
<Box
component="main"
sx={{
background: spaceAppBackground,
color: textBase,
display: "grid",
- height: isThreadOpen ? "100dvh" : undefined,
- minHeight: isThreadOpen ? 0 : "100svh",
+ height: isThreadOpen
+ ? "var(--space-page-height, 100dvh)"
+ : undefined,
+ minHeight: isThreadOpen
+ ? 0
+ : "var(--space-page-height, 100svh)",
overflow: isThreadOpen ? "hidden" : undefined,
overflowX: "hidden",
placeItems: { xs: "stretch", sm: "start center" },
@@ -2604,7 +2107,9 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
: "56px minmax(0, 1fr) auto"
: undefined,
height: isThreadOpen ? "100%" : undefined,
- minHeight: isThreadOpen ? 0 : "100svh",
+ minHeight: isThreadOpen
+ ? 0
+ : "var(--space-page-height, 100svh)",
mx: "auto",
overflow: isThreadOpen ? "hidden" : undefined,
position: "relative",
@@ -2624,19 +2129,20 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
}}
>
<Box
- component="button"
- type="button"
- aria-label={isThreadOpen ? threadBackLabel : "Back"}
- onClick={isThreadOpen ? onCloseThread : onBack}
+ component={isThreadOpen ? "button" : "span"}
+ type={isThreadOpen ? "button" : undefined}
+ aria-hidden={!isThreadOpen || undefined}
+ aria-label={
+ isThreadOpen ? threadBackLabel : undefined
+ }
+ onClick={isThreadOpen ? onCloseThread : undefined}
sx={{
alignItems: "center",
bgcolor: "transparent",
border: 0,
color: conversationPrimaryText,
- cursor:
- isThreadOpen || onBack
- ? "pointer"
- : "default",
+ cursor: isThreadOpen ? "pointer" : undefined,
+ visibility: isThreadOpen ? "visible" : "hidden",
display: "flex",
height: spaceTouchTargetSize,
justifyContent: "flex-start",
@@ -2747,49 +2253,7 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
Messages
</Box>
)}
- {isThreadOpen && selectedFriend && canInteract ? (
- <Box
- component="button"
- type="button"
- aria-label={
- selectedName
- ? `Poke ${selectedName}`
- : "Send poke"
- }
- disabled={!canPoke}
- onClick={sendPoke}
- sx={{
- alignItems: "center",
- appearance: "none",
- bgcolor: "transparent",
- border: 0,
- borderRadius: "50%",
- color: "inherit",
- cursor: canPoke ? "pointer" : "default",
- display: "flex",
- height: spaceTouchTargetSize,
- justifyContent: "center",
- justifySelf: "end",
- lineHeight: 1,
- mr: "-8px",
- opacity: canPoke ? 1 : 0.5,
- p: 0,
- width: spaceTouchTargetSize,
- "&:focus-visible": {
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- }}
- >
- <HugeiconsIcon
- icon={HandPointingRightIcon}
- size={24}
- strokeWidth={1.8}
- />
- </Box>
- ) : (
- <Box aria-hidden />
- )}
+ <Box aria-hidden />
</Box>
{isThreadOpen && selectedFriend ? (
@@ -3174,7 +2638,7 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
boxSizing: "border-box",
display: "grid",
gap: "8px",
- p: "10px 14px calc(10px + env(safe-area-inset-bottom))",
+ p: "10px 14px",
width: "100%",
}}
>
@@ -3485,27 +2949,27 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
</Box>
) : (
<Box
+ component="ul"
sx={{
- boxSizing: "border-box",
- m: 0,
- p: "6px 16px 28px",
+ ...spaceActivityListSx,
+ listStyle: "none",
}}
>
- {conversationSections.map((section) => (
- <ConversationSection
- key={section.title}
- activityPostsByKey={
- activityPostsByKey
- }
- latestPostCreatedAtMs={
- latestPostCreatedAtMs
- }
- onConfirmFriendRequest={
- onConfirmFriendRequest
- }
- onDeleteFriendRequest={
- onDeleteFriendRequest
+ {conversations.map((conversation) => (
+ <ConversationListItem
+ key={conversationId(conversation)}
+ activityPost={
+ conversation.latestActivity.post
+ ? activityPostsByKey[
+ postQuoteKey(
+ conversation
+ .latestActivity
+ .post,
+ )
+ ]
+ : undefined
}
+ conversation={conversation}
onLoadActivityPost={
loadActivityPost
}
@@ -3513,10 +2977,6 @@ export const MessagesScreen: React.FC<MessagesScreenProps> = ({
onOpenSelectedFriendProfile
}
onOpenThread={onOpenThread}
- onPostSomething={
- openPostPhotoPicker
- }
- section={section}
/>
))}
</Box>
diff --git a/web/apps/space/src/screens/ProfileImageViewerScreen.tsx b/web/apps/space/src/screens/ProfileImageViewerScreen.tsx
index 561f200ddb..a944ff0caa 100644
--- a/web/apps/space/src/screens/ProfileImageViewerScreen.tsx
+++ b/web/apps/space/src/screens/ProfileImageViewerScreen.tsx
@@ -208,7 +208,7 @@ export const ProfileImageViewerScreen: React.FC<
background: spaceAppBackground,
color: textBase,
display: "grid",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
overflowX: "hidden",
placeItems: { xs: "stretch", sm: "start center" },
}}
@@ -219,7 +219,7 @@ export const ProfileImageViewerScreen: React.FC<
boxSizing: "border-box",
display: "grid",
gridTemplateRows: "56px minmax(0, 1fr) auto",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
mx: "auto",
width: "100%",
"@media (min-width: 600px)": { maxWidth: 390 },
diff --git a/web/apps/space/src/screens/ProfileScreen.tsx b/web/apps/space/src/screens/ProfileScreen.tsx
index e5f122921e..d6479c32d9 100644
--- a/web/apps/space/src/screens/ProfileScreen.tsx
+++ b/web/apps/space/src/screens/ProfileScreen.tsx
@@ -2,7 +2,7 @@ import {
AddSquareIcon,
ArrowLeft02Icon,
BubbleChatIcon,
- Menu01Icon,
+ HandPointingRightIcon,
MoreHorizontalIcon,
Tick02Icon,
UserRemove01Icon,
@@ -11,6 +11,7 @@ import { HugeiconsIcon } from "@hugeicons/react";
import { Box, Menu, MenuItem, Skeleton } from "@mui/material";
import {
spaceActionDoneDurationMs,
+ SpaceActionFeedbackIcon,
type SpaceActionPhase,
} from "components/ActionFeedback";
import {
@@ -20,13 +21,11 @@ import {
import { SpaceAvatarImage } from "components/AvatarImage";
import { SpaceButtonSpinner } from "components/ButtonSpinner";
import { ConfirmationActionSheet } from "components/ConfirmationActionSheet";
-import { SpaceFeedPostButton } from "components/FeedPostButton";
import {
SpaceFileViewer,
type SpaceViewerPhoto,
type SpaceViewerPostActionMode,
} from "components/FileViewer";
-import { SpacePostComposer } from "components/PostComposer";
import { SpacePostGrid } from "components/PostGrid";
import { SpacePostPhotoInput } from "components/PostPhotoInput";
import { SpacePostTile, type SpacePostTileItem } from "components/PostTile";
@@ -51,10 +50,7 @@ import {
} from "styles/colors";
import { spaceTouchTargetSize } from "styles/touch-targets";
import { firstNameFrom } from "utils/display";
-import {
- spaceDefaultCoverImagePath,
- type SpaceDraftPostImage,
-} from "utils/post-image";
+import { spaceDefaultCoverImagePath } from "utils/post-image";
import { viewerPhotosFromPost } from "utils/post-photos";
const green = "#08C225";
@@ -214,24 +210,21 @@ interface ProfileScreenProps {
isCoverLoading?: boolean;
isNameLoading?: boolean;
isPostsLoading?: boolean;
+ isPostPhotoOpening?: boolean;
isStatsLoading?: boolean;
showPostLoadingIndicator?: boolean;
- onBack?: () => void;
- onPostSubmitted?: () => void;
onAddFriend?: () => void;
onAddFriendForPostAction?: (intent: SpaceInviteIntent) => void;
+ onBack?: () => void;
onCreateSpace?: () => void;
- onCreatePost?: (
- images: SpaceDraftPostImage[],
- caption: string,
- ) => Promise<void>;
+ onPostPhotoSelect?: (files: File[]) => void;
onDeletePost?: (postId: number) => Promise<void> | void;
onOpenFriends?: () => void;
onOpenProfileCover?: () => void;
onOpenProfilePhoto?: () => void;
- onOpenSettings?: () => void;
onLoadPostImage?: (asset: SpacePostAsset) => Promise<string>;
onMessageFriend?: () => void;
+ onPokeFriend?: (requestID: string) => Promise<void>;
onReplyToPost?: (
postSpaceId: string,
postId: number,
@@ -256,20 +249,20 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
isCoverLoading = false,
isNameLoading = false,
isPostsLoading = false,
+ isPostPhotoOpening = false,
isStatsLoading = false,
onBack,
- onPostSubmitted,
onAddFriend,
onAddFriendForPostAction,
onCreateSpace,
- onCreatePost,
+ onPostPhotoSelect,
onDeletePost,
onOpenFriends,
onOpenProfileCover,
onOpenProfilePhoto,
- onOpenSettings,
onLoadPostImage,
onMessageFriend,
+ onPokeFriend,
onReplyToPost,
onSetPostLiked,
onUnfriend,
@@ -285,14 +278,15 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
}) => {
const [selectedPost, setSelectedPost] =
useState<SelectedProfilePost | null>(null);
- const [draftFiles, setDraftFiles] = useState<File[] | null>(null);
- const isPostPhotoOpening = Boolean(draftFiles);
const [isInviteLinkCopied, setIsInviteLinkCopied] = useState(false);
const [deletedPostIDs, setDeletedPostIDs] = useState<Set<string>>(
() => new Set(),
);
const [friendActionsAnchor, setFriendActionsAnchor] =
useState<HTMLElement | null>(null);
+ const [pokePhase, setPokePhase] = useState<SpaceActionPhase>();
+ const [pokeFailed, setPokeFailed] = useState(false);
+ const pokeRequestID = React.useRef<string | undefined>(undefined);
const [isUnfriendSheetOpen, setIsUnfriendSheetOpen] = useState(false);
const [unfriendActionPhase, setUnfriendActionPhase] =
useState<SpaceActionPhase | null>(null);
@@ -322,7 +316,9 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
const friendActionsMenuID = React.useId();
const isFriendActionsOpen = Boolean(friendActionsAnchor);
const isUnfriendActionRunning = unfriendActionPhase != null;
- const canManageFriend = isFriendProfile && Boolean(onUnfriend);
+ const canManageFriend =
+ isFriendProfile &&
+ Boolean(onMessageFriend || onPokeFriend || onUnfriend);
const displayName = profile.fullName.trim() || profile.username.trim();
const coverUrl = profile.coverUrl ?? null;
const isCoverURLPending = Boolean(profile.coverObjectID && !coverUrl);
@@ -365,6 +361,32 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
: profilePostLoadRootMargin;
const closeFriendActions = () => setFriendActionsAnchor(null);
+ const poke = async () => {
+ if (!onPokeFriend || pokePhase) return;
+ setPokePhase("busy");
+ setPokeFailed(false);
+ pokeRequestID.current ??= crypto.randomUUID();
+ try {
+ await onPokeFriend(pokeRequestID.current);
+ pokeRequestID.current = undefined;
+ setPokePhase("done");
+ } catch (error) {
+ log.error("Failed to send poke", error);
+ setPokeFailed(true);
+ setPokePhase(undefined);
+ }
+ };
+
+ React.useEffect(() => {
+ if (pokePhase != "done") return;
+
+ const timeoutID = window.setTimeout(() => {
+ setFriendActionsAnchor(null);
+ }, spaceActionDoneDurationMs);
+
+ return () => window.clearTimeout(timeoutID);
+ }, [pokePhase]);
+
const requestUnfriend = () => {
closeFriendActions();
setUnfriendErrorMessage(null);
@@ -605,7 +627,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
: undefined,
mx: "auto",
position: "relative",
- px: "8px",
+ px: isPublicProfile ? 1 : 2,
py: 0,
width: "100%",
zIndex: 3,
@@ -654,20 +676,22 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
) : (
<>
<Box
- component="button"
- type="button"
+ component={isFriendProfile ? "button" : "span"}
+ type={isFriendProfile ? "button" : undefined}
+ aria-hidden={!isFriendProfile || undefined}
aria-label={
- isFriendProfile
- ? "Back to friends"
- : "Back to home"
+ isFriendProfile ? "Back to friends" : undefined
}
- onClick={onBack}
+ onClick={isFriendProfile ? onBack : undefined}
sx={{
alignItems: "center",
bgcolor: "transparent",
border: 0,
color: "inherit",
- cursor: "pointer",
+ cursor: isFriendProfile ? "pointer" : undefined,
+ visibility: isFriendProfile
+ ? "visible"
+ : "hidden",
display: "flex",
height: spaceTouchTargetSize,
justifyContent: "flex-start",
@@ -707,77 +731,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
>
{firstName}
</Box>
- {isOwnerProfile ? (
- <Box
- component="button"
- type="button"
- aria-label="Settings"
- onClick={onOpenSettings}
- sx={{
- alignItems: "center",
- bgcolor: "transparent",
- border: 0,
- color: "inherit",
- cursor: onOpenSettings
- ? "pointer"
- : "default",
- display: "flex",
- height: spaceTouchTargetSize,
- justifyContent: "flex-end",
- p: 0,
- width: spaceTouchTargetSize,
- "&:focus-visible": {
- borderRadius: "50%",
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- }}
- >
- <HugeiconsIcon
- icon={Menu01Icon}
- size={20}
- strokeWidth={2.4}
- />
- </Box>
- ) : onMessageFriend ? (
- <Box
- component="button"
- type="button"
- aria-label={`Message ${displayName}`}
- onClick={onMessageFriend}
- sx={{
- alignItems: "center",
- bgcolor: "transparent",
- border: 0,
- color: "inherit",
- cursor: "pointer",
- display: "flex",
- height: spaceTouchTargetSize,
- justifyContent: "flex-end",
- p: 0,
- width: spaceTouchTargetSize,
- "& svg path:last-of-type": {
- display: "none",
- },
- "&:focus-visible": {
- borderRadius: "50%",
- outline: `2px solid ${green}`,
- outlineOffset: 2,
- },
- }}
- >
- <HugeiconsIcon
- icon={BubbleChatIcon}
- size={20}
- strokeWidth={2}
- />
- </Box>
- ) : (
- <Box
- aria-hidden
- sx={{ width: spaceTouchTargetSize }}
- />
- )}
+ <Box aria-hidden sx={{ width: spaceTouchTargetSize }} />
</>
)}
</Box>
@@ -791,7 +745,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
background: spaceAppBackground,
color: textBase,
display: "grid",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
overflowX: "hidden",
placeItems: { xs: "stretch", sm: "start center" },
position: "relative",
@@ -804,7 +758,7 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
boxSizing: "border-box",
display: "flex",
flexDirection: "column",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
mx: "auto",
overflow: "hidden",
position: "relative",
@@ -812,10 +766,10 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
"@media (min-width: 600px)": { maxWidth: 390 },
}}
>
- {isOwnerProfile && (
+ {isOwnerProfile && onPostPhotoSelect && (
<SpacePostPhotoInput
inputRef={postInputRef}
- onSelect={setDraftFiles}
+ onSelect={onPostPhotoSelect}
/>
)}
<Box
@@ -1093,11 +1047,13 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
: undefined
}
aria-haspopup="menu"
- onClick={(event) =>
+ onClick={(event) => {
+ if (pokePhase == "done")
+ setPokePhase(undefined);
setFriendActionsAnchor(
event.currentTarget,
- )
- }
+ );
+ }}
sx={{
alignItems: "center",
bgcolor: "transparent",
@@ -1161,6 +1117,127 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
},
}}
>
+ {onMessageFriend && (
+ <MenuItem
+ dense
+ disableRipple
+ onClick={() => {
+ closeFriendActions();
+ onMessageFriend();
+ }}
+ sx={{
+ borderRadius: "10px",
+ color: textBase,
+ gap: "8px",
+ minHeight: 36,
+ px: "9px",
+ py: "4px",
+ whiteSpace: "nowrap",
+ "&.Mui-focusVisible": {
+ bgcolor:
+ "rgba(255, 255, 255, 0.08)",
+ },
+ "&:active": {
+ bgcolor:
+ "rgba(255, 255, 255, 0.08)",
+ },
+ "&:hover": {
+ bgcolor:
+ "rgba(255, 255, 255, 0.08)",
+ },
+ }}
+ >
+ <HugeiconsIcon
+ icon={BubbleChatIcon}
+ size={18}
+ strokeWidth={1.8}
+ />
+ <Box
+ sx={{
+ fontFamily:
+ '"Inter Variable", Inter, sans-serif',
+ fontSize: 13,
+ fontWeight: 650,
+ lineHeight: "18px",
+ }}
+ >
+ Message
+ </Box>
+ </MenuItem>
+ )}
+ {onPokeFriend && (
+ <MenuItem
+ dense
+ disableRipple
+ onClick={() => void poke()}
+ disabled={pokePhase !== undefined}
+ sx={{
+ borderRadius: "10px",
+ color: textBase,
+ gap: "8px",
+ minHeight: 36,
+ px: "9px",
+ py: "4px",
+ whiteSpace: "nowrap",
+ "&.Mui-disabled": {
+ color: textBase,
+ opacity: 1,
+ },
+ "&.Mui-focusVisible": {
+ bgcolor:
+ "rgba(255, 255, 255, 0.08)",
+ },
+ "&:active": {
+ bgcolor:
+ "rgba(255, 255, 255, 0.08)",
+ },
+ "&:hover": {
+ bgcolor:
+ "rgba(255, 255, 255, 0.08)",
+ },
+ }}
+ >
+ <SpaceActionFeedbackIcon
+ phase={pokePhase ?? null}
+ size={18}
+ idleIcon={
+ <HugeiconsIcon
+ icon={
+ HandPointingRightIcon
+ }
+ size={18}
+ strokeWidth={1.8}
+ />
+ }
+ />
+ <Box
+ sx={{
+ fontFamily:
+ '"Inter Variable", Inter, sans-serif',
+ fontSize: 13,
+ fontWeight: 650,
+ lineHeight: "18px",
+ }}
+ >
+ {pokePhase == "done"
+ ? "Poked"
+ : "Poke"}
+ </Box>
+ </MenuItem>
+ )}
+ {pokeFailed && (
+ <Box
+ role="alert"
+ sx={{
+ color: textSoft,
+ fontSize: 12,
+ px: "9px",
+ py: "4px",
+ }}
+ >
+ Couldn&apos;t send poke. Try again.
+ </Box>
+ )}
{onUnfriend && (
<MenuItem
dense
@@ -1424,21 +1501,6 @@ export const ProfileScreen: React.FC<ProfileScreenProps> = ({
</Box>
)}
</Box>
- {isOwnerProfile && hasProfilePosts && (
- <SpaceFeedPostButton
- disabled={isPostPhotoOpening}
- onClick={openPostPhotoPicker}
- />
- )}
- {draftFiles && onCreatePost && (
- <SpacePostComposer
- files={draftFiles}
- onClose={() => setDraftFiles(null)}
- onPublish={onCreatePost}
- onPublished={onPostSubmitted}
- profile={profile}
- />
- )}
{selectedPost && (
<SpaceFileViewer
photo={selectedPost.photo}
diff --git a/web/apps/space/src/screens/SettingsScreen.tsx b/web/apps/space/src/screens/SettingsScreen.tsx
index 399a8639a8..3c15826d23 100644
--- a/web/apps/space/src/screens/SettingsScreen.tsx
+++ b/web/apps/space/src/screens/SettingsScreen.tsx
@@ -416,7 +416,7 @@ export const SettingsScreen: React.FC<SettingsScreenProps> = ({
background: spaceAppBackground,
color: textBase,
display: "grid",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
overflowX: "hidden",
placeItems: { xs: "stretch", sm: "start center" },
}}
@@ -428,7 +428,7 @@ export const SettingsScreen: React.FC<SettingsScreenProps> = ({
boxSizing: "border-box",
display: "flex",
flexDirection: "column",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
mx: "auto",
width: "100%",
"@media (min-width: 600px)": { maxWidth: 390 },
@@ -448,7 +448,7 @@ export const SettingsScreen: React.FC<SettingsScreenProps> = ({
<Box
component="button"
type="button"
- aria-label="Back to profile"
+ aria-label="Back to home"
onClick={onBack}
sx={{
alignItems: "center",
@@ -659,7 +659,7 @@ export const ChangeNameSettingsScreen: React.FC<
background: spaceAppBackground,
color: textBase,
display: "grid",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
overflowX: "hidden",
placeItems: { xs: "stretch", sm: "start center" },
}}
@@ -671,7 +671,7 @@ export const ChangeNameSettingsScreen: React.FC<
boxSizing: "border-box",
display: "flex",
flexDirection: "column",
- minHeight: "100svh",
+ minHeight: "var(--space-page-height, 100svh)",
mx: "auto",
width: "100%",
"@media (min-width: 600px)": { maxWidth: 390 },
diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.ts
index 830194d0af..6db450bda2 100644
--- a/web/apps/space/src/services/space.ts
+++ b/web/apps/space/src/services/space.ts
@@ -44,6 +44,7 @@ import {
releaseCurrentSpaceContext,
} from "services/profile";
import { normalizeSpaceMessageText } from "utils/message-limits";
+import { spaceUnreadStatusChangedEvent } from "utils/navigation";
import { spacePostDeletedEvent } from "utils/post-events";
import { postQuoteErrorState, postQuotePhotoIndex } from "utils/post-quote";
@@ -147,7 +148,7 @@ interface PublicSpaceIdentityResponse {
type SpaceMessageKind = MessageResponse["kind"];
-export interface SpaceMessageQuote {
+export interface SpacePostPreview {
durationMs?: number;
imageUrl?: string;
isUnavailable?: boolean;
@@ -159,6 +160,8 @@ export interface SpaceMessageQuote {
spaceId: string;
}
+export type SpaceMessageQuote = SpacePostPreview;
+
export interface SpaceMessage {
createdAtMs: number;
id: string;
@@ -227,6 +230,7 @@ export interface SpaceFriendRequest {
export interface SpaceUnreadStatus {
messagesUnread: boolean;
+ notificationsUnread: boolean;
}
export const isSpaceContentError = (error: unknown) =>
@@ -747,10 +751,10 @@ const messageActivityPostFromActivity = (
};
};
-export const loadCurrentMessageActivityPostPreview = async (
- post: SpaceMessageActivityPost,
+export const loadCurrentPostPreview = async (
+ post: SpacePostPreview,
viewerSpaceId?: string,
-): Promise<SpaceMessageActivityPost | undefined> => {
+): Promise<SpacePostPreview | undefined> => {
const ctx = await ensureCurrentSpaceContext();
try {
const response = await loadSpaceMedia(() =>
@@ -794,22 +798,15 @@ const isPokeMessageActivity = (activity: SpaceMessageActivity) =>
activity.kind == "poke";
const isPassiveAutoReadMessageActivity = (activity: SpaceMessageActivity) =>
- activity.type == "friend_added" ||
- activity.type == "message_like" ||
- activity.type == "post_like" ||
- isPokeMessageActivity(activity);
+ activity.type == "message_like" || isPokeMessageActivity(activity);
const messageConversationUnreadCount = (activities: SpaceMessageActivity[]) => {
const onlyActivity = activities.length == 1 ? activities[0] : undefined;
- if (
- onlyActivity?.type == "post_like" ||
- (onlyActivity && isPokeMessageActivity(onlyActivity))
- ) {
+ if (onlyActivity && isPokeMessageActivity(onlyActivity)) {
return 0;
}
return activities.filter((activity) => {
- if (activity.type == "friend_added") return false;
if (activity.type == "message_like") return false;
return true;
}).length;
@@ -1002,20 +999,81 @@ export const loadCurrentUnreadStatus = async (
): Promise<SpaceUnreadStatus> => {
const ctx = await ensureCurrentSpaceContext();
try {
- const status = await ctx.unreadStatus(spaceId);
- return { messagesUnread: status.notificationsUnread };
+ const [status, notificationsUnread] = await Promise.all([
+ ctx.unreadStatus(spaceId),
+ ctx.notificationsUnread(spaceId),
+ ]);
+ return {
+ messagesUnread: status.notificationsUnread,
+ notificationsUnread,
+ };
} finally {
releaseCurrentSpaceContext(ctx);
}
};
-export const hasCurrentSpacePosts = async (
+export interface SpaceNotification {
+ id: string;
+ kind: string;
+ actors: FriendProfile[];
+ actorCount: number;
+ postId?: number;
+ friendRequestId?: number;
+ createdAtMs: number;
+ read: boolean;
+}
+
+export const loadCurrentNotifications = async (
spaceId: string,
-): Promise<boolean> => {
+ cursor?: string,
+) => {
const ctx = await ensureCurrentSpaceContext();
try {
- const page = await ctx.listPosts(spaceId, spaceId, null, 1);
- return page.items.length > 0;
+ const page = await ctx.listNotifications(spaceId, cursor, 20);
+ return {
+ items: await Promise.all(
+ page.items.map(async (item): Promise<SpaceNotification> => {
+ const actors = await Promise.all(
+ item.actors.map(async (itemActor) => {
+ const actor = actorProfile(itemActor);
+ actor.avatarUrl =
+ await cachedAccountAvatarURLIfPresent(
+ actor.spaceId,
+ itemActor.avatar,
+ );
+ return actor;
+ }),
+ );
+ return {
+ id: item.notificationId,
+ kind: item.kind,
+ actors,
+ actorCount: item.actorCount,
+ postId: item.postId ?? undefined,
+ friendRequestId: item.friendRequestId ?? undefined,
+ createdAtMs: timestampMsFromSpaceDate(item.createdAt),
+ read: !item.unread,
+ };
+ }),
+ ),
+ nextCursor: page.nextCursor || undefined,
+ latestPostCreatedAtMs: page.latestPostCreatedAt
+ ? timestampMsFromSpaceDate(page.latestPostCreatedAt)
+ : null,
+ };
+ } finally {
+ releaseCurrentSpaceContext(ctx);
+ }
+};
+
+export const markCurrentNotificationItemsRead = async (
+ spaceId: string,
+ ids: string[],
+) => {
+ const ctx = await ensureCurrentSpaceContext();
+ try {
+ await ctx.markNotificationItemsRead(spaceId, ids);
+ window.dispatchEvent(new Event(spaceUnreadStatusChangedEvent));
} finally {
releaseCurrentSpaceContext(ctx);
}
@@ -1116,7 +1174,9 @@ export const loadCurrentSpacePostAvatarURL: SpacePostAvatarURLLoader = async (
export const loadCurrentFriendAvatarURL = async (
friend: FriendProfile,
+ viewerSpaceId?: string,
): Promise<string | null> => {
+ if (friend.avatarUrl) return friend.avatarUrl;
if (!friend.spaceId || !friend.avatarObjectID || !friend.avatarKeyVersion) {
return null;
}
@@ -1131,14 +1191,15 @@ export const loadCurrentFriendAvatarURL = async (
);
if (cachedAvatarURL) return cachedAvatarURL;
- const profile = await loadExistingSpaceProfile();
+ const actorSpaceId =
+ viewerSpaceId ?? (await loadExistingSpaceProfile())?.spaceId;
const ctx = await ensureCurrentSpaceContext();
try {
return await accountAvatarURL(
ctx,
friend.spaceId,
avatar,
- profile?.spaceId,
+ actorSpaceId,
);
} finally {
releaseCurrentSpaceContext(ctx);
@@ -1350,18 +1411,11 @@ export const sendCurrentMessage = async (
export const sendCurrentPoke = async (
senderSpaceId: string,
spaceId: string,
- sender: FriendProfile,
- recipient: FriendProfile,
+ requestId: string,
) => {
const ctx = await ensureCurrentSpaceContext();
try {
- return await messageFromSpaceMessage(
- ctx,
- await ctx.sendPoke(senderSpaceId, spaceId),
- true,
- senderSpaceId,
- { friend: recipient, viewer: sender },
- );
+ await ctx.sendPoke(senderSpaceId, spaceId, requestId);
} finally {
releaseCurrentSpaceContext(ctx);
}
@@ -1471,21 +1525,8 @@ export const loadCurrentMessageConversations = async (
};
}),
);
- const requestItems = response.pendingRequests.map((request) => ({
- friend: actorProfile(request.requester),
- latestActivity: {
- createdAtMs: timestampMsFromSpaceDate(request.createdAt),
- id: `friend_request:${request.requestId}`,
- outgoing: false,
- type: "friend_request" as const,
- },
- notificationUnread: true,
- unread: true,
- unreadActivities: [],
- unreadCount: 1,
- }));
return {
- items: [...requestItems, ...friendItems],
+ items: friendItems,
latestPostCreatedAtMs: response.latestPostCreatedAt
? timestampMsFromSpaceDate(response.latestPostCreatedAt)
: null,
@@ -1495,34 +1536,6 @@ export const loadCurrentMessageConversations = async (
}
};
-export const loadCurrentMessageConversationAvatar = async (
- viewerSpaceId: string,
- friend: FriendProfile,
-) => {
- if (
- friend.avatarUrl ||
- !friend.avatarObjectID ||
- !friend.avatarKeyVersion
- ) {
- return friend.avatarUrl ?? null;
- }
-
- const ctx = await ensureCurrentSpaceContext();
- try {
- return await accountAvatarURL(
- ctx,
- friendSpaceId(friend),
- {
- keyVersion: friend.avatarKeyVersion,
- objectID: friend.avatarObjectID,
- },
- viewerSpaceId,
- );
- } finally {
- releaseCurrentSpaceContext(ctx);
- }
-};
-
export const confirmCurrentFriendRequest = async (
spaceId: string,
requestId: number,
@@ -1590,6 +1603,7 @@ export const markCurrentMessagesRead = async (
const ctx = await ensureCurrentSpaceContext();
try {
await ctx.markNotificationsRead(spaceId, friendSpaceId);
+ window.dispatchEvent(new Event(spaceUnreadStatusChangedEvent));
} finally {
releaseCurrentSpaceContext(ctx);
}
diff --git a/web/apps/space/src/state/navigation.ts b/web/apps/space/src/state/navigation.ts
new file mode 100644
index 0000000000..21d824dbb4
--- /dev/null
+++ b/web/apps/space/src/state/navigation.ts
@@ -0,0 +1,14 @@
+import React from "react";
+import type { SpaceUnreadStatus } from "services/space";
+
+export const emptySpaceUnreadStatus: SpaceUnreadStatus = {
+ messagesUnread: false,
+ notificationsUnread: false,
+};
+
+export const SpaceUnreadStatusContext = React.createContext(
+ emptySpaceUnreadStatus,
+);
+
+export const useSpaceUnreadStatus = () =>
+ React.useContext(SpaceUnreadStatusContext);
diff --git a/web/apps/space/src/styles/activity-list.ts b/web/apps/space/src/styles/activity-list.ts
new file mode 100644
index 0000000000..a912dac7dd
--- /dev/null
+++ b/web/apps/space/src/styles/activity-list.ts
@@ -0,0 +1,36 @@
+import { spaceSurface, spaceText, spaceTextMuted } from "styles/colors";
+
+export const spaceActivityListSx = {
+ boxSizing: "border-box",
+ m: 0,
+ p: "6px 16px 28px",
+} as const;
+
+export const spaceActivityRowSx = {
+ alignItems: "center",
+ borderRadius: "8px",
+ boxSizing: "border-box",
+ color: spaceText,
+ display: "grid",
+ gap: "10px",
+ minHeight: 64,
+ mx: "-8px",
+ p: "8px",
+ textAlign: "left",
+ transition: "background-color 140ms ease",
+ width: "calc(100% + 16px)",
+ "&:active": { bgcolor: spaceSurface },
+ "&:hover": { bgcolor: spaceSurface },
+} as const;
+
+export const spaceActivityPreviewSx = {
+ color: spaceTextMuted,
+ fontFamily: '"Inter Variable", Inter, sans-serif',
+ fontSize: 13,
+ fontWeight: 500,
+ lineHeight: "18px",
+ minWidth: 0,
+ overflow: "hidden",
+ textOverflow: "ellipsis",
+ whiteSpace: "nowrap",
+} as const;
diff --git a/web/apps/space/src/styles/globals.css b/web/apps/space/src/styles/globals.css
index 8a250af373..252880fecc 100644
--- a/web/apps/space/src/styles/globals.css
+++ b/web/apps/space/src/styles/globals.css
@@ -7,79 +7,61 @@
-webkit-tap-highlight-color: transparent;
}
-html[data-space-route-motion] {
- overflow-x: hidden;
-}
-
-html[data-space-route-motion]::view-transition-old(root),
-html[data-space-route-motion]::view-transition-new(root) {
- animation-duration: 220ms;
- animation-fill-mode: both;
- animation-timing-function: cubic-bezier(0.2, 0, 0, 1);
- mix-blend-mode: normal;
+.space-app-layout {
+ --space-bottom-nav-height: calc(60px + env(safe-area-inset-bottom));
+ --space-page-height: calc(
+ var(--space-viewport-height, 100svh) - var(--space-bottom-nav-height)
+ );
+ min-height: 100svh;
+ padding-bottom: var(--space-bottom-nav-height);
}
-html[data-space-route-motion="forward"]::view-transition-old(root) {
- animation-name: space-route-forward-old;
+::view-transition-group(space-bottom-nav) {
+ z-index: 1;
+ animation: none;
}
-html[data-space-route-motion="forward"]::view-transition-new(root) {
- animation-name: space-route-forward-new;
+::view-transition-old(space-bottom-nav) {
+ display: none;
}
-html[data-space-route-motion="back"]::view-transition-old(root) {
- animation-name: space-route-back-old;
+::view-transition-new(space-bottom-nav) {
+ animation: none;
}
-html[data-space-route-motion="back"]::view-transition-new(root) {
- animation-name: space-route-back-new;
+html[data-space-route-motion]::view-transition-old(root),
+html[data-space-route-motion]::view-transition-new(root) {
+ animation-duration: 180ms;
+ animation-fill-mode: both;
+ animation-timing-function: cubic-bezier(0.2, 0, 0, 1);
+ mix-blend-mode: normal;
}
-@keyframes space-route-forward-old {
- from {
- opacity: 1;
- transform: translateX(0);
- }
-
- to {
- opacity: 0.92;
- transform: translateX(-18px);
- }
+html[data-space-route-motion]::view-transition-old(root) {
+ animation-name: space-route-fade-out;
}
-@keyframes space-route-forward-new {
- from {
- opacity: 0.96;
- transform: translateX(28px);
- }
-
- to {
- opacity: 1;
- transform: translateX(0);
- }
+html[data-space-route-motion]::view-transition-new(root) {
+ animation-name: space-route-fade-in;
}
-@keyframes space-route-back-old {
+@keyframes space-route-fade-out {
from {
opacity: 1;
- transform: translateX(0);
}
to {
- opacity: 0.92;
- transform: translateX(18px);
+ opacity: 0;
}
}
-@keyframes space-route-back-new {
+@keyframes space-route-fade-in {
from {
- opacity: 0.96;
- transform: translateX(-28px);
+ opacity: 0;
}
to {
opacity: 1;
- transform: translateX(0);
}
}
diff --git a/web/apps/space/src/utils/activity-sections.ts b/web/apps/space/src/utils/activity-sections.ts
new file mode 100644
index 0000000000..cd6fe34b81
--- /dev/null
+++ b/web/apps/space/src/utils/activity-sections.ts
@@ -0,0 +1,59 @@
+export const groupSpaceActivities = <T>(
+ items: T[],
+ activity: (item: T) => { createdAtMs: number; isNew: boolean },
+) => {
+ const today = new Date();
+ const startOfTodayMs = new Date(
+ today.getFullYear(),
+ today.getMonth(),
+ today.getDate(),
+ ).getTime();
+ const startOfYesterdayMs = new Date(
+ today.getFullYear(),
+ today.getMonth(),
+ today.getDate() - 1,
+ ).getTime();
+ const mondayDate = today.getDate() - ((today.getDay() + 6) % 7);
+ const startOfThisWeekMs = new Date(
+ today.getFullYear(),
+ today.getMonth(),
+ mondayDate,
+ ).getTime();
+ const startOfLastWeekMs = new Date(
+ today.getFullYear(),
+ today.getMonth(),
+ mondayDate - 7,
+ ).getTime();
+ const startOfThisMonthMs = new Date(
+ today.getFullYear(),
+ today.getMonth(),
+ 1,
+ ).getTime();
+ const sections: { title: string; items: T[] }[] = [
+ { title: "New", items: [] },
+ { title: "Today", items: [] },
+ { title: "Yesterday", items: [] },
+ { title: "This week", items: [] },
+ { title: "Last week", items: [] },
+ { title: "This month", items: [] },
+ { title: "Earlier", items: [] },
+ ];
+ for (const item of items) {
+ const { createdAtMs, isNew } = activity(item);
+ const index = isNew
+ ? 0
+ : createdAtMs >= startOfTodayMs
+ ? 1
+ : createdAtMs >= startOfYesterdayMs
+ ? 2
+ : createdAtMs >= startOfThisWeekMs
+ ? 3
+ : createdAtMs >= startOfLastWeekMs
+ ? 4
+ : createdAtMs >= startOfThisMonthMs
+ ? 5
+ : 6;
+ sections[index]!.items.push(item);
+ }
+ return sections;
+};
diff --git a/web/apps/space/src/utils/navigation.ts b/web/apps/space/src/utils/navigation.ts
new file mode 100644
index 0000000000..30a42f605b
--- /dev/null
+++ b/web/apps/space/src/utils/navigation.ts
@@ -0,0 +1,21 @@
+import { spaceRoutes } from "utils/routes";
+
+export const spaceUnreadStatusChangedEvent = "space-unread-status-changed";
+
+export const spaceNavigationDestination = (pathname: string) => {
+ if (pathname == spaceRoutes.friendPage) return spaceRoutes.friends;
+ for (const destination of [
+ spaceRoutes.friends,
+ spaceRoutes.messages,
+ spaceRoutes.profile,
+ ]) {
+ if (pathname == destination || pathname.startsWith(`${destination}/`))
+ return destination;
+ }
+ if (
+ pathname == spaceRoutes.home ||
+ pathname.startsWith(`${spaceRoutes.home}/`)
+ )
+ return spaceRoutes.home;
+ return undefined;
+};
diff --git a/web/apps/space/src/utils/page-titles.ts b/web/apps/space/src/utils/page-titles.ts
index 9ad8670ca5..f478e4fc83 100644
--- a/web/apps/space/src/utils/page-titles.ts
+++ b/web/apps/space/src/utils/page-titles.ts
@@ -10,6 +10,7 @@ const pageTitles: Record<string, string> = {
"/app/friends": "Friends",
"/app/messages": "Messages",
"/app/messages/[spaceId]": "Messages",
+ "/app/notifications": "Notifications",
"/app/post": "Create post",
"/app/posts/[spaceId]/[postId]": "Post",
"/app/profile": "Your profile",
diff --git a/web/apps/space/src/utils/route-transitions.tsx b/web/apps/space/src/utils/route-transitions.tsx
index 35a22fb5c6..e514d4209f 100644
--- a/web/apps/space/src/utils/route-transitions.tsx
+++ b/web/apps/space/src/utils/route-transitions.tsx
@@ -37,6 +37,7 @@ const parentRoutePaths = (path: string) => {
{
"/app/friends": ["/app/profile"],
"/app/messages": ["/app"],
+ "/app/notifications": ["/app"],
"/app/profile": ["/app"],
"/app/profile/cover": ["/app/profile"],
"/app/profile/cover-edit": ["/app/profile/cover"],
@@ -76,20 +77,6 @@ const routeMotionDirection = (
return "forward";
};
-const routeSlideDirection = (
- currentPath: string,
- targetPath: string | undefined,
- direction: SpaceRouteMotionDirection,
-): SpaceRouteMotionDirection => {
- if (currentPath == "/app" && targetPath == "/app/settings") {
- return "back";
- }
- if (currentPath == "/app/settings" && targetPath == "/app") {
- return "forward";
- }
- return direction;
-};
-
const recordRoutePush = (
currentPath: string,
targetPath: string,
@@ -126,10 +113,7 @@ const recordRouteReplace = (targetPath: string) => {
const prefersReducedMotion = () =>
window.matchMedia("(prefers-reduced-motion: reduce)").matches;
-const startSpaceRouteTransition = async <T,>(
- direction: SpaceRouteMotionDirection,
- updateRoute: () => Promise<T>,
-) => {
+const startSpaceRouteTransition = async <T,>(updateRoute: () => Promise<T>) => {
if (
typeof document == "undefined" ||
typeof document.startViewTransition != "function" ||
@@ -142,7 +126,7 @@ const startSpaceRouteTransition = async <T,>(
const root = document.documentElement;
let result: T;
- root.dataset.spaceRouteMotion = direction;
+ root.dataset.spaceRouteMotion = "fade";
const transition = document.startViewTransition(async () => {
result = await updateRoute();
@@ -178,9 +162,8 @@ const pushSpaceRoute = async (
}
const direction = routeMotionDirection(currentPath, targetPath);
- const didNavigate = await startSpaceRouteTransition(
- routeSlideDirection(currentPath, targetPath, direction),
- () => router.push(url, as, options),
+ const didNavigate = await startSpaceRouteTransition(() =>
+ router.push(url, as, options),
);
if (didNavigate) recordRoutePush(currentPath, targetPath, direction);
return didNavigate;
@@ -201,40 +184,32 @@ const backSpaceRoute = (router: NextRouter) => {
const currentPath = routePath(router.asPath);
const targetPath = previousStackRoute();
- void startSpaceRouteTransition(
- routeSlideDirection(currentPath, targetPath, "back"),
- () => {
- const routeChangePromise = new Promise<boolean>(
- (resolve, reject) => {
- const cleanup = () => {
- router.events.off(
- "routeChangeComplete",
- handleComplete,
- );
- router.events.off("routeChangeError", handleError);
- };
- const handleComplete = () => {
- cleanup();
- resolve(true);
- };
- const handleError = (error: unknown) => {
- cleanup();
- reject(
- error instanceof Error
- ? error
- : new Error("Space route change failed"),
- );
- };
-
- router.events.on("routeChangeComplete", handleComplete);
- router.events.on("routeChangeError", handleError);
- },
- );
+ void startSpaceRouteTransition(() => {
+ const routeChangePromise = new Promise<boolean>((resolve, reject) => {
+ const cleanup = () => {
+ router.events.off("routeChangeComplete", handleComplete);
+ router.events.off("routeChangeError", handleError);
+ };
+ const handleComplete = () => {
+ cleanup();
+ resolve(true);
+ };
+ const handleError = (error: unknown) => {
+ cleanup();
+ reject(
+ error instanceof Error
+ ? error
+ : new Error("Space route change failed"),
+ );
+ };
+
+ router.events.on("routeChangeComplete", handleComplete);
+ router.events.on("routeChangeError", handleError);
+ });
- router.back();
- return routeChangePromise;
- },
- )
+ router.back();
+ return routeChangePromise;
+ })
.then((didNavigate) => {
if (didNavigate && targetPath) {
recordRoutePush(currentPath, targetPath, "back");
@@ -296,9 +271,8 @@ export const useSpaceRouteTransitionPopState = () => {
if (!targetPath || targetPath == currentPath) return true;
- void startSpaceRouteTransition(
- routeSlideDirection(currentPath, targetPath, "back"),
- () => router.replace(state.url, state.as, state.options),
+ void startSpaceRouteTransition(() =>
+ router.replace(state.url, state.as, state.options),
)
.then((didNavigate) => {
if (didNavigate) {
diff --git a/web/apps/space/src/utils/routes.ts b/web/apps/space/src/utils/routes.ts
index 96a430f7f3..9f78406d15 100644
--- a/web/apps/space/src/utils/routes.ts
+++ b/web/apps/space/src/utils/routes.ts
@@ -22,6 +22,7 @@ export const spaceRoutes = {
message: (spaceId: string) =>
`/app/messages/${encodeURIComponent(spaceId)}`,
messages: "/app/messages",
+ notifications: "/app/notifications",
onboarding: "/",
passkeysFinish: "/passkeys/finish",
passkeysVerify: "/passkeys/verify",
diff --git a/web/apps/space/tests/activity-sections.test.ts b/web/apps/space/tests/activity-sections.test.ts
new file mode 100644
index 0000000000..92db5eaeb9
--- /dev/null
+++ b/web/apps/space/tests/activity-sections.test.ts
@@ -0,0 +1,104 @@
+import { afterEach, expect, test, vi } from "vitest";
+import { groupSpaceActivities } from "../src/utils/activity-sections";
+
+afterEach(() => vi.useRealTimers());
+
+test("new activity takes priority and history follows local calendar boundaries", () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date(2026, 9, 21, 12));
+ const items = [
+ {
+ id: "old-unread",
+ createdAtMs: new Date(2026, 7, 1).getTime(),
+ isNew: true,
+ },
+ {
+ id: "today",
+ createdAtMs: new Date(2026, 9, 21).getTime(),
+ isNew: false,
+ },
+ {
+ id: "yesterday",
+ createdAtMs: new Date(2026, 9, 20).getTime(),
+ isNew: false,
+ },
+ {
+ id: "this-week",
+ createdAtMs: new Date(2026, 9, 19).getTime(),
+ isNew: false,
+ },
+ {
+ id: "last-week",
+ createdAtMs: new Date(2026, 9, 12).getTime(),
+ isNew: false,
+ },
+ {
+ id: "this-month",
+ createdAtMs: new Date(2026, 9, 1).getTime(),
+ isNew: false,
+ },
+ {
+ id: "earlier",
+ createdAtMs: new Date(2026, 8, 30, 23, 59).getTime(),
+ isNew: false,
+ },
+ ];
+ expect(
+ groupSpaceActivities(items, (item) => item).map((section) => ({
+ title: section.title,
+ ids: section.items.map((item) => item.id),
+ })),
+ ).toEqual([
+ { title: "New", ids: ["old-unread"] },
+ { title: "Today", ids: ["today"] },
+ { title: "Yesterday", ids: ["yesterday"] },
+ { title: "This week", ids: ["this-week"] },
+ { title: "Last week", ids: ["last-week"] },
+ { title: "This month", ids: ["this-month"] },
+ { title: "Earlier", ids: ["earlier"] },
+ ]);
+});
+
+test.each([
+ {
+ name: "Sunday stays in the current week",
+ now: new Date(2026, 9, 25, 12),
+ dates: [new Date(2026, 9, 19), new Date(2026, 9, 18, 23, 59)],
+ titles: ["This week", "Last week"],
+ },
+ {
+ name: "yesterday takes priority when Monday crosses a year boundary",
+ now: new Date(2027, 0, 4, 12),
+ dates: [
+ new Date(2027, 0, 3),
+ new Date(2027, 0, 1),
+ new Date(2026, 11, 28),
+ new Date(2026, 11, 27, 23, 59),
+ ],
+ titles: ["Yesterday", "Last week", "Last week", "Earlier"],
+ },
+ {
+ name: "calendar weeks span month and daylight-saving boundaries",
+ now: new Date(2026, 10, 4, 12),
+ dates: [
+ new Date(2026, 10, 2),
+ new Date(2026, 10, 1),
+ new Date(2026, 9, 26),
+ new Date(2026, 9, 25, 23, 59),
+ ],
+ titles: ["This week", "Last week", "Last week", "Earlier"],
+ },
+])("$name", ({ now, dates, titles }) => {
+ vi.useFakeTimers();
+ vi.setSystemTime(now);
+ const sections = groupSpaceActivities(dates, (date) => ({
+ createdAtMs: date.getTime(),
+ isNew: false,
+ }));
+ expect(
+ dates.map(
+ (date) =>
+ sections.find((section) => section.items.includes(date))?.title,
+ ),
+ ).toEqual(titles);
+});
diff --git a/web/apps/space/tests/navigation.test.ts b/web/apps/space/tests/navigation.test.ts
new file mode 100644
index 0000000000..7734f0a8da
--- /dev/null
+++ b/web/apps/space/tests/navigation.test.ts
@@ -0,0 +1,20 @@
+import { spaceNavigationDestination } from "utils/navigation";
+import { describe, expect, it } from "vitest";
+
+describe("navigation destinations", () => {
+ it.each([
+ ["/app", "/app"],
+ ["/app/notifications", "/app"],
+ ["/app/settings/profile/name", "/app"],
+ ["/app/post", "/app"],
+ ["/app/posts/[spaceId]/[postId]", "/app"],
+ ["/app/messages/[spaceId]", "/app/messages"],
+ ["/app/friends", "/app/friends"],
+ ["/profile-link", "/app/friends"],
+ ["/app/profile/photo-edit", "/app/profile"],
+ ["/login", undefined],
+ ["/application", undefined],
+ ])("keeps %s in its parent destination", (path, destination) => {
+ expect(spaceNavigationDestination(path)).toBe(destination);
+ });
+});
diff --git a/web/apps/space/tests/notification-avatars.test.ts b/web/apps/space/tests/notification-avatars.test.ts
new file mode 100644
index 0000000000..259a783451
--- /dev/null
+++ b/web/apps/space/tests/notification-avatars.test.ts
@@ -0,0 +1,212 @@
+import { beforeEach, expect, test, vi } from "vitest";
+import {
+ cachedSpaceMediaBlobURL,
+ cachedSpaceMediaBlobURLIfPresent,
+ spaceProfileMediaCacheKey,
+} from "../src/services/media-cache";
+import {
+ ensureCurrentSpaceContext,
+ loadExistingSpaceProfile,
+ releaseCurrentSpaceContext,
+} from "../src/services/profile";
+import {
+ loadCurrentFriendAvatarURL,
+ loadCurrentMessageConversations,
+ loadCurrentNotifications,
+} from "../src/services/space";
+
+vi.mock("ente-base/log", () => ({ default: { warn: vi.fn() } }));
+vi.mock("ente-accounts/services/accounts-db", () => ({
+ savedPartialLocalUser: () => ({ id: 1 }),
+}));
+vi.mock("ente-base/log-web", () => ({ logToDisk: vi.fn() }));
+vi.mock("services/feed-cache", () => ({}));
+vi.mock("services/profile", () => ({
+ ensureCurrentSpaceContext: vi.fn(),
+ loadExistingSpaceProfile: vi.fn(),
+ releaseCurrentSpaceContext: vi.fn(),
+}));
+vi.mock("services/media-cache", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("../src/services/media-cache")>()),
+ cachedSpaceMediaBlobURL: vi.fn(),
+ cachedSpaceMediaBlobURLIfPresent: vi.fn(),
+}));
+
+const actor = {
+ spaceId: "friend-space",
+ spaceSlug: "maya",
+ profile: { fullName: "Maya Patel" },
+ avatar: { objectID: "avatar-1", keyVersion: 2 },
+};
+const createdAt = "2026-10-07T06:00:00Z";
+const context = {
+ downloadSpaceAvatar: vi.fn(),
+ listNotifications: vi.fn(),
+ listConversations: vi.fn(),
+};
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(ensureCurrentSpaceContext).mockResolvedValue(
+ context as unknown as Awaited<
+ ReturnType<typeof ensureCurrentSpaceContext>
+ >,
+ );
+ context.listNotifications.mockResolvedValue({
+ items: [
+ {
+ notificationId: "like-1",
+ kind: "post_like",
+ actors: [actor],
+ actorCount: 1,
+ unread: true,
+ postId: 42,
+ createdAt,
+ },
+ ],
+ });
+ context.listConversations.mockResolvedValue({
+ friends: [{ friend: actor, createdAt }],
+ chatSummaries: new Map(),
+ pendingRequests: [],
+ });
+ vi.mocked(cachedSpaceMediaBlobURLIfPresent).mockResolvedValue(undefined);
+});
+
+test("notifications restore the same cached avatar as Messages before returning rows", async () => {
+ vi.mocked(cachedSpaceMediaBlobURLIfPresent).mockResolvedValue(
+ "blob:cached-avatar",
+ );
+
+ const notifications = await loadCurrentNotifications("viewer-space");
+ const messages = await loadCurrentMessageConversations("viewer-space");
+
+ expect(notifications.items[0]?.actors[0]?.avatarUrl).toBe(
+ "blob:cached-avatar",
+ );
+ expect(notifications.items[0]?.actors[0]).toEqual(
+ messages.items[0]?.friend,
+ );
+ expect(cachedSpaceMediaBlobURLIfPresent).toHaveBeenCalledWith(
+ spaceProfileMediaCacheKey(actor.spaceId, "avatar", "avatar-1", 2),
+ );
+ expect(context.downloadSpaceAvatar).not.toHaveBeenCalled();
+});
+
+test("notification groups preserve full counts with only the latest two actors", async () => {
+ const secondActor = {
+ ...actor,
+ spaceId: "second-friend",
+ spaceSlug: "sam",
+ profile: { fullName: "Sam Reed" },
+ };
+ context.listNotifications.mockResolvedValue({
+ items: [
+ {
+ notificationId: "like-50",
+ kind: "post_like",
+ actors: [actor, secondActor],
+ actorCount: 50,
+ unread: true,
+ postId: 42,
+ createdAt,
+ },
+ ],
+ nextCursor: "next-post-group",
+ });
+
+ const page = await loadCurrentNotifications("viewer-space");
+
+ expect(context.listNotifications).toHaveBeenCalledWith(
+ "viewer-space",
+ undefined,
+ 20,
+ );
+ expect(page.items).toHaveLength(1);
+ expect(page.items[0]).toMatchObject({
+ id: "like-50",
+ actorCount: 50,
+ read: false,
+ actors: [{ fullName: "Maya Patel" }, { fullName: "Sam Reed" }],
+ });
+ expect(page.nextCursor).toBe("next-post-group");
+});
+
+test("uncached avatars use the selected viewer without loading another profile", async () => {
+ const page = await loadCurrentNotifications("viewer-space");
+ const friend = page.items[0]!.actors[0]!;
+ vi.mocked(cachedSpaceMediaBlobURL).mockImplementation(async (_, load) => {
+ await load();
+ return "blob:downloaded-avatar";
+ });
+ context.downloadSpaceAvatar.mockResolvedValue(new Uint8Array([1]));
+
+ await expect(
+ loadCurrentFriendAvatarURL(friend, "viewer-space"),
+ ).resolves.toBe("blob:downloaded-avatar");
+
+ expect(context.downloadSpaceAvatar).toHaveBeenCalledWith(
+ actor.spaceId,
+ "viewer-space",
+ "avatar-1",
+ 2,
+ );
+ expect(loadExistingSpaceProfile).not.toHaveBeenCalled();
+ expect(releaseCurrentSpaceContext).toHaveBeenCalledWith(context);
+});
+
+test("friend notifications preserve request targets without inventing post targets", async () => {
+ context.listNotifications.mockResolvedValue({
+ items: [
+ {
+ notificationId: "request-1",
+ kind: "friend_request",
+ actors: [{ spaceId: "requester", spaceSlug: "maya" }],
+ actorCount: 1,
+ friendRequestId: 7,
+ createdAt,
+ unread: true,
+ },
+ {
+ notificationId: "accepted-1",
+ kind: "friend_accepted",
+ actors: [actor],
+ actorCount: 1,
+ createdAt,
+ unread: false,
+ },
+ ],
+ });
+ const page = await loadCurrentNotifications("viewer-space");
+ expect(page.items).toHaveLength(2);
+ expect(page.items[0]).toMatchObject({
+ kind: "friend_request",
+ friendRequestId: 7,
+ postId: undefined,
+ read: false,
+ });
+ expect(page.items[0]?.actors[0]?.fullName).toBe("maya");
+ expect(page.items[0]?.actors[0]?.avatarObjectID).toBeUndefined();
+ expect(page.items[1]).toMatchObject({
+ kind: "friend_accepted",
+ friendRequestId: undefined,
+ postId: undefined,
+ read: true,
+ });
+});
+
+test("already hydrated avatars do not start another lookup or download", async () => {
+ const page = await loadCurrentNotifications("viewer-space");
+ const friend = {
+ ...page.items[0]!.actors[0]!,
+ avatarUrl: "blob:cached-avatar",
+ };
+ vi.clearAllMocks();
+
+ await expect(
+ loadCurrentFriendAvatarURL(friend, "viewer-space"),
+ ).resolves.toBe("blob:cached-avatar");
+
+ expect(cachedSpaceMediaBlobURLIfPresent).not.toHaveBeenCalled();
+ expect(ensureCurrentSpaceContext).not.toHaveBeenCalled();
+});