π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Reduce unread badge and notification loading overhead
Anand Baburajaned66cb588e5d
diff --git a/rust/crates/space/src/client/messages.rs b/rust/crates/space/src/client/messages.rsindex b895d21164..2b18a33a75 100644--- a/rust/crates/space/src/client/messages.rs+++ b/rust/crates/space/src/client/messages.rs@@ -451,7 +451,7 @@ impl AccountSpaceCtx {.await}- async fn decrypt_message_fields(+ pub(super) async fn decrypt_message_fields(&self,space_id: &str,kind: &str,diff --git a/rust/crates/space/src/client/posts.rs b/rust/crates/space/src/client/posts.rsindex e5a3be3571..bf5fac9172 100644--- a/rust/crates/space/src/client/posts.rs+++ b/rust/crates/space/src/client/posts.rs@@ -1,6 +1,6 @@use super::{- AccountSpaceCtx, PostPhotoInput, decrypt_post_object_metadata, ensure_post_objects_supported,- retain_content_error,+ AccountSpaceCtx, MESSAGE_KIND_POKE, MESSAGE_KIND_REGULAR, PostPhotoInput,+ decrypt_post_object_metadata, ensure_post_objects_supported, retain_content_error,};use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key};use crate::error::{Error, Result};@@ -10,7 +10,8 @@ use crate::models::{};use crate::transport::{CreatePostRequest, CreatePostResponse, LikePostResponse, PostObjectPayload, PostPageResponse,- PostResponse, SpaceActorResponse, SpaceUnreadStatusResponse, UpdatePostCaptionRequest,+ PostResponse, SpaceActorResponse, SpaceUnreadStatusResponse, UnreadActivityPageResponse,+ UpdatePostCaptionRequest,};use ente_core::{b64, http};@@ -195,12 +196,40 @@ impl AccountSpaceCtx {.json().await?;if status.notifications_unread {- status.notifications_unread = self- .list_conversations(space_id)- .await?- .chat_summaries- .values()- .any(|summary| !summary.unread_activities.is_empty());+ let path = format!("/spaces/{space_id}/unread/activities");+ let mut cursor = String::new();+ loop {+ let page: UnreadActivityPageResponse = self+ .api()+ .get(&path)+ .query(&[("cursor", &cursor)])+ .send()+ .await?+ .error_for_status()?+ .json()+ .await?;+ for activity in page.items {+ if activity.kind != MESSAGE_KIND_REGULAR+ || !retain_content_error(+ self.decrypt_message_fields(+ space_id,+ &activity.kind,+ &activity.encrypted_message_key,+ &activity.message_cipher,+ )+ .await,+ )?+ .is_ok_and(|payload| payload.kind == MESSAGE_KIND_POKE)+ {+ return Ok(status);+ }+ }+ if page.next_cursor.is_empty() {+ status.notifications_unread = false;+ break;+ }+ cursor = page.next_cursor;+ }}Ok(status)}diff --git a/rust/crates/space/src/client/tests.rs b/rust/crates/space/src/client/tests.rsindex d0667de12d..b450a8b67c 100644--- a/rust/crates/space/src/client/tests.rs+++ b/rust/crates/space/src/client/tests.rs@@ -1695,6 +1695,57 @@ async fn like_post_uses_post_like_endpoint() {like.assert_async().await;}+#[tokio::test]+async fn unread_badge_stops_without_loading_conversations() {+ for kind in ["regular", "post_reply"] {+ 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 cipher = b64::encode(+ &encrypt_secretbox_payload(+ &key,+ &serde_json::to_vec(&json!({"version":1,"kind":kind,"text":"Hello"})).unwrap(),+ )+ .unwrap(),+ );+ let status = server+ .mock("GET", "/spaces/space_owner_main/unread")+ .with_body(json!({"notificationsUnread":true}).to_string())+ .create_async()+ .await;+ let activities = server+ .mock("GET", "/spaces/space_owner_main/unread/activities")+ .match_query(Matcher::UrlEncoded("cursor".into(), String::new()))+ .with_body(json!({"items":[{"kind":kind,"messageCipher":cipher,"encryptedMessageKey":encrypted_key}],"nextCursor":"older"}).to_string())+ .create_async()+ .await;+ let older = server+ .mock("GET", "/spaces/space_owner_main/unread/activities")+ .match_query(Matcher::UrlEncoded("cursor".into(), "older".into()))+ .expect(0)+ .create_async()+ .await;+ let conversations = server+ .mock("GET", "/spaces/space_owner_main/conversations")+ .with_status(500)+ .expect(0)+ .create_async()+ .await;+ assert!(+ ctx.unread_status("space_owner_main")+ .await+ .unwrap()+ .notifications_unread+ );+ status.assert_async().await;+ activities.assert_async().await;+ older.assert_async().await;+ conversations.assert_async().await;+ }+}+#[tokio::test]async fn unread_methods_use_read_marker_endpoints() {let mut server = Server::new_async().await;@@ -2433,7 +2484,21 @@ async fn legacy_pokes_are_hidden_from_threads_previews_and_unread_status() {}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;+ .expect(1).create_async().await;+ let unread_first = server+ .mock("GET", "/spaces/space_owner_main/unread/activities")+ .match_query(Matcher::UrlEncoded("cursor".into(), String::new()))+ .with_body(json!({"items":[poke],"nextCursor":"older"}).to_string())+ .create_async()+ .await;+ let unread_second = server+ .mock("GET", "/spaces/space_owner_main/unread/activities")+ .match_query(Matcher::UrlEncoded("cursor".into(), "older".into()))+ .with_body(+ json!({"items":if has_message {vec![message.clone()]} else {vec![]}}).to_string(),+ )+ .create_async()+ .await;let first = server.mock("GET",@@ -2441,7 +2506,7 @@ async fn legacy_pokes_are_hidden_from_threads_previews_and_unread_status() {).match_query(Matcher::Exact("limit=100".into())).with_body(json!({"items":[poke],"nextCursor":"older"}).to_string())- .expect(2)+ .expect(1).create_async().await;let second = server@@ -2454,7 +2519,7 @@ async fn legacy_pokes_are_hidden_from_threads_previews_and_unread_status() {Matcher::UrlEncoded("limit".into(), "100".into()),])).with_body(json!({"items":if has_message {vec![message]} else {vec![]}}).to_string())- .expect(2)+ .expect(1).create_async().await;let status = server@@ -2490,6 +2555,8 @@ async fn legacy_pokes_are_hidden_from_threads_previews_and_unread_status() {has_message);conversations.assert_async().await;+ unread_first.assert_async().await;+ unread_second.assert_async().await;first.assert_async().await;second.assert_async().await;status.assert_async().await;diff --git a/rust/crates/space/src/transport.rs b/rust/crates/space/src/transport.rsindex fe2d11cdef..bb3b41f6f6 100644--- a/rust/crates/space/src/transport.rs+++ b/rust/crates/space/src/transport.rs@@ -129,6 +129,22 @@ pub struct SpaceUnreadStatusResponse {pub notifications_unread: bool,}+#[derive(Debug, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct UnreadActivityResponse {+ pub kind: String,+ pub message_cipher: String,+ pub encrypted_message_key: String,+}++#[derive(Debug, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct UnreadActivityPageResponse {+ pub items: Vec<UnreadActivityResponse>,+ #[serde(default)]+ pub next_cursor: String,+}+#[derive(Debug, Clone, Serialize, Deserialize)]pub struct LikeMessageResponse {pub liked: bool,diff --git a/rust/crates/space/tests/space.rs b/rust/crates/space/tests/space.rsindex be815dc69b..831dac703a 100644--- a/rust/crates/space/tests/space.rs+++ b/rust/crates/space/tests/space.rs@@ -365,6 +365,28 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {.unwrap().notifications_unread);+ friend_ctx+ .send_message(&friend_space.space_id, &owner_space.space_id, "Hello")+ .await+ .unwrap();+ assert!(+ owner_ctx+ .unread_status(&owner_space.space_id)+ .await+ .unwrap()+ .notifications_unread+ );+ owner_ctx+ .mark_notifications_read(&owner_space.space_id, &friend_space.space_id)+ .await+ .unwrap();+ assert!(+ !owner_ctx+ .unread_status(&owner_space.space_id)+ .await+ .unwrap()+ .notifications_unread+ );space::assert_http_status(outsider_ctx.send_poke(diff --git a/server/space/api/notifications_test.go b/server/space/api/notifications_test.goindex 54eef7198d..734f82cca6 100644--- a/server/space/api/notifications_test.go+++ b/server/space/api/notifications_test.go@@ -2,6 +2,7 @@ package apiimport ("crypto/sha256"+ "encoding/base64""encoding/json""net/http""net/http/httptest"@@ -12,6 +13,7 @@ import (timeutil "github.com/ente/museum/pkg/utils/time""github.com/ente/museum/space/controller""github.com/ente/museum/space/models"+ "github.com/ente/museum/space/repo""github.com/gin-gonic/gin""github.com/stretchr/testify/require")@@ -79,6 +81,29 @@ func TestNotificationsAPIIsRecipientScoped(t *testing.T) {require.Equal(t, http.StatusOK, response.Code)response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/notifications/unread", "")require.JSONEq(t, `{"unread":false}`, response.Body.String())+ _, err = repos.Messages.CreateMessage(ctx, repo.CreateSpaceMessageRecord{+ Kind: "regular",+ SenderSpaceID: friend.SpaceID,+ RecipientSpaceID: owner.SpaceID,+ MessageCipher: []byte("cipher"),+ SenderEncryptedMessageKey: []byte("sender-key"),+ RecipientEncryptedMessageKey: []byte("recipient-key"),+ })+ require.NoError(t, err)+ response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/unread/activities?limit=1", "")+ require.Equal(t, http.StatusOK, response.Code, response.Body.String())+ var unreadPage models.UnreadActivityPage+ require.NoError(t, json.Unmarshal(response.Body.Bytes(), &unreadPage))+ require.Equal(t, []models.UnreadActivityResponse{{+ Kind: "regular",+ MessageCipher: base64.StdEncoding.EncodeToString([]byte("cipher")),+ EncryptedMessageKey: base64.StdEncoding.EncodeToString([]byte("recipient-key")),+ }}, unreadPage.Items)+ require.Empty(t, unreadPage.NextCursor)+ response = serve(http.MethodGet, "/spaces/"+friend.SpaceID+"/unread/activities", "")+ require.Equal(t, http.StatusForbidden, response.Code)+ response = serve(http.MethodGet, "/spaces/"+owner.SpaceID+"/unread/activities?limit=101", "")+ require.Equal(t, http.StatusBadRequest, response.Code)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)diff --git a/server/space/api/read_markers.go b/server/space/api/read_markers.goindex ba6f51fa81..4f229926ec 100644--- a/server/space/api/read_markers.go+++ b/server/space/api/read_markers.go@@ -1,10 +1,20 @@package apiimport (+ "github.com/ente/museum/space/models"spacerepo "github.com/ente/museum/space/repo""github.com/gin-gonic/gin")+func (h *Handlers) ListUnreadActivities(c *gin.Context, space *spacerepo.SpaceRecord) {+ var req models.ListUnreadActivitiesRequest+ if !bindQuery(c, &req) {+ return+ }+ resp, err := h.Module.Read.ListUnreadActivities(c, space, req)+ respondJSON(c, resp, err)+}+func (h *Handlers) GetUnreadStatus(c *gin.Context, space *spacerepo.SpaceRecord) {resp, err := h.Module.Read.GetUnreadStatus(c, space)respondJSON(c, resp, err)diff --git a/server/space/api/register.go b/server/space/api/register.goindex c8fedb7c70..4d4adb3cbd 100644--- a/server/space/api/register.go+++ b/server/space/api/register.go@@ -15,6 +15,7 @@ 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("/unread/activities", selected(handlers.ListUnreadActivities))spaceAPI.GET("/notifications", selected(handlers.ListNotifications))spaceAPI.GET("/notifications/unread", selected(handlers.GetNotificationUnread))spaceAPI.POST("/notifications/read", selected(handlers.ReadNotifications))diff --git a/server/space/controller/read_markers.go b/server/space/controller/read_markers.goindex 3638fcb27a..5b6e5c413d 100644--- a/server/space/controller/read_markers.go+++ b/server/space/controller/read_markers.go@@ -16,6 +16,22 @@ type ReadMarkersController struct {ReadMarkersRepo *repo.ReadMarkersRepository}+func (c *ReadMarkersController) ListUnreadActivities(ctx context.Context, viewerSpace *repo.SpaceRecord, req models.ListUnreadActivitiesRequest) (*models.UnreadActivityPage, error) {+ activities, nextCursor, err := c.ReadMarkersRepo.ListUnreadActivities(ctx, viewerSpace.SpaceID, req.Cursor, req.Limit)+ if err != nil {+ return nil, err+ }+ items := make([]models.UnreadActivityResponse, 0, len(activities))+ for _, activity := range activities {+ items = append(items, models.UnreadActivityResponse{+ Kind: activity.Kind,+ MessageCipher: encodeSpaceField(activity.MessageCipher),+ EncryptedMessageKey: encodeSpaceField(activity.EncryptedMessageKey),+ })+ }+ return &models.UnreadActivityPage{Items: items, NextCursor: nextCursor}, nil+}+func (c *ReadMarkersController) GetUnreadStatus(ctx context.Context, viewerSpace *repo.SpaceRecord) (*models.SpaceUnreadStatusResponse, error) {notificationsUnread, err := c.ReadMarkersRepo.HasUnreadNotifications(ctx, viewerSpace.SpaceID)if err != nil {diff --git a/server/space/models/models.go b/server/space/models/models.goindex 6c72de0b03..bb060b3024 100644--- a/server/space/models/models.go+++ b/server/space/models/models.go@@ -408,6 +408,22 @@ type SpaceUnreadStatusResponse struct {NotificationsUnread bool `json:"notificationsUnread"`}+type ListUnreadActivitiesRequest struct {+ Cursor string `form:"cursor"`+ Limit int `form:"limit" binding:"omitempty,min=1,max=100"`+}++type UnreadActivityResponse struct {+ Kind string `json:"kind"`+ MessageCipher string `json:"messageCipher"`+ EncryptedMessageKey string `json:"encryptedMessageKey"`+}++type UnreadActivityPage struct {+ Items []UnreadActivityResponse `json:"items"`+ NextCursor string `json:"nextCursor,omitempty"`+}+type PostPage struct {Items []PostResponse `json:"items"`NextCursor string `json:"nextCursor,omitempty"`diff --git a/server/space/repo/notifications.go b/server/space/repo/notifications.goindex 76e56883a2..5227fe06e1 100644--- a/server/space/repo/notifications.go+++ b/server/space/repo/notifications.go@@ -55,9 +55,6 @@ func (r *NotificationsRepository) List(ctx context.Context, recipientSpaceID, cu` + 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,- ARRAY_AGG(notification_id) OVER (PARTITION BY kind, group_id) AS notification_ids,- 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 positionFROM visible), page AS (@@ -69,9 +66,18 @@ func (r *NotificationsRepository) List(ctx context.Context, recipientSpaceID, cu}args = append(args, limit+1)query += ` ORDER BY created_at DESC, notification_id DESC LIMIT $` + strconv.Itoa(len(args)) + `+ ), grouped AS MATERIALIZED (+ SELECT visible.kind, visible.group_id,+ ARRAY_AGG(visible.notification_id) AS notification_ids,+ CASE WHEN visible.kind = 'post_like' THEN COUNT(*) ELSE 1 END AS actor_count,+ BOOL_OR(visible.read_at IS NULL) AS unread+ FROM visible+ JOIN page ON page.kind = visible.kind AND page.group_id = visible.group_id+ GROUP BY visible.kind, visible.group_id)- SELECT page.notification_id, page.notification_ids, page.kind, page.post_id, page.friend_request_id, page.created_at, page.actor_count, page.unread, ` + spaceActorSelectColumns("actor", "avatar", "actor") + `+ SELECT page.notification_id, grouped.notification_ids, page.kind, page.post_id, page.friend_request_id, page.created_at, grouped.actor_count, grouped.unread, ` + spaceActorSelectColumns("actor", "avatar", "actor") + `FROM page+ JOIN grouped ON grouped.kind = page.kind AND grouped.group_id = page.group_idJOIN ranked sample ON sample.kind = page.kind AND sample.group_id = page.group_idAND sample.position <= CASE WHEN page.kind = 'post_like' THEN 2 ELSE 1 ENDJOIN spaces actor ON actor.space_id = sample.actor_space_iddiff --git a/server/space/repo/notifications_test.go b/server/space/repo/notifications_test.goindex f9136f0065..2e576520a1 100644--- a/server/space/repo/notifications_test.go+++ b/server/space/repo/notifications_test.go@@ -310,6 +310,58 @@ func TestNotificationsPaginateCompletePostGroups(t *testing.T) {require.Empty(t, next)}+func TestNotificationsLargeLikeGroup(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)+ _, err = module.Pokes.Create(ctx, bob.SpaceID, alice.SpaceID, "older")+ require.NoError(t, err)+ _, err = module.Spaces.DB.ExecContext(ctx, `+ INSERT INTO spaces (space_id, owner_id, space_slug, root_wrapped_space_key, public_key, encrypted_secret_key)+ SELECT 'large-group-' || i, $1, 'large_group_' || i, '\x00'::bytea, '\x00'::bytea, '\x00'::bytea+ FROM generate_series(1, 2000) i+ `, bob.OwnerID)+ require.NoError(t, err)+ _, err = module.Friends.DB.ExecContext(ctx, `+ INSERT INTO space_friend_shares (space_id, friend_space_id, friend_sealed_space_key, key_version)+ SELECT $1, 'large-group-' || i, '\x00'::bytea, 1 FROM generate_series(1, 2000) i+ `, alice.SpaceID)+ require.NoError(t, err)+ _, err = module.Posts.DB.ExecContext(ctx, `+ INSERT INTO space_post_likes (like_id, post_id, actor_space_id)+ SELECT 'large-like-' || i, $1, 'large-group-' || i FROM generate_series(1, 2000) i+ `, postID)+ require.NoError(t, err)+ _, err = module.Notifications.DB.ExecContext(ctx, `+ INSERT INTO space_notifications (notification_id, recipient_space_id, actor_space_id, kind, post_like_id, read_at)+ SELECT 'large-notification-' || i, $1, 'large-group-' || i, 'post_like', 'large-like-' || i,+ CASE WHEN i = 1 THEN NULL ELSE now_utc_micro_seconds() END+ FROM generate_series(1, 2000) i+ `, alice.SpaceID)+ require.NoError(t, err)+ page, cursor, err := module.Notifications.List(ctx, alice.SpaceID, "", 1)+ require.NoError(t, err)+ require.Len(t, page, 1)+ require.Equal(t, postID, page[0].PostID.Int64)+ require.Equal(t, int64(2000), page[0].ActorCount)+ require.Len(t, page[0].NotificationIDs, 2000)+ require.Len(t, page[0].Actors, 2)+ require.True(t, page[0].Unread)+ require.NotEmpty(t, cursor)+ require.NoError(t, module.Notifications.MarkRead(ctx, alice.SpaceID, page[0].NotificationIDs))+ page, _, err = module.Notifications.List(ctx, alice.SpaceID, "", 1)+ require.NoError(t, err)+ require.False(t, page[0].Unread)+ older, cursor, err := module.Notifications.List(ctx, alice.SpaceID, cursor, 1)+ require.NoError(t, err)+ require.Len(t, older, 1)+ require.Equal(t, "poke", older[0].Kind)+ require.Len(t, older[0].NotificationIDs, 1)+ require.Empty(t, cursor)+}+func TestNotificationReadAfterLatestLikeRemoved(t *testing.T) {for _, newLike := range []bool{false, true} {t.Run(fmt.Sprintf("newLike=%t", newLike), func(t *testing.T) {diff --git a/server/space/repo/read_markers.go b/server/space/repo/read_markers.goindex 195840e975..607c9f19bb 100644--- a/server/space/repo/read_markers.go+++ b/server/space/repo/read_markers.go@@ -3,12 +3,73 @@ package repoimport ("context""database/sql"+ "strconv""strings""github.com/ente/stacktrace""github.com/lib/pq")+type SpaceUnreadActivityRecord struct {+ MessageID string+ Kind string+ MessageCipher []byte+ EncryptedMessageKey []byte+ CreatedAt int64+}++func (r *ReadMarkersRepository) ListUnreadActivities(ctx context.Context, viewerSpaceID, cursor string, limit int) ([]SpaceUnreadActivityRecord, string, error) {+ limit = optionalInt(limit, 50)+ if limit > 100 {+ limit = 100+ }+ query := `WITH unread AS (+ SELECT m.message_id, m.kind, m.message_cipher,+ CASE WHEN m.sender_space_id = $1 THEN m.sender_encrypted_message_key ELSE m.recipient_encrypted_message_key END AS encrypted_message_key,+ CASE WHEN m.recipient_space_id = $1 THEN m.created_at ELSE m.recipient_liked_at END AS created_at+ FROM space_messages m+ JOIN space_friend_shares share ON share.space_id = $1+ AND share.friend_space_id = CASE WHEN m.sender_space_id = $1 THEN m.recipient_space_id ELSE m.sender_space_id END+ JOIN spaces friend ON friend.space_id = share.friend_space_id+ JOIN users friend_owner ON friend_owner.user_id = friend.owner_id AND friend_owner.encrypted_email IS NOT NULL+ LEFT JOIN space_notification_read_markers marker ON marker.viewer_space_id = $1 AND marker.friend_space_id = share.friend_space_id+ WHERE m.is_deleted = FALSE AND m.kind IN ('regular', 'post_reply')+ AND ((m.recipient_space_id = $1 AND m.created_at > COALESCE(marker.read_at, 0))+ OR (m.sender_space_id = $1 AND m.recipient_liked_at > COALESCE(marker.read_at, 0)))+ )+ SELECT message_id, kind, message_cipher, encrypted_message_key, created_at FROM unread`+ args := []any{viewerSpaceID}+ if createdAt, id, ok := parseMessageCursor(cursor); ok {+ query += ` WHERE (created_at, message_id) < ($2, $3)`+ args = append(args, createdAt, id)+ }+ args = append(args, limit+1)+ query += ` ORDER BY created_at DESC, message_id DESC LIMIT $` + strconv.Itoa(len(args))+ rows, err := r.DB.QueryContext(ctx, query, args...)+ if err != nil {+ return nil, "", stacktrace.Propagate(err, "")+ }+ defer rows.Close()+ items := make([]SpaceUnreadActivityRecord, 0)+ for rows.Next() {+ var item SpaceUnreadActivityRecord+ if err := rows.Scan(&item.MessageID, &item.Kind, &item.MessageCipher, &item.EncryptedMessageKey, &item.CreatedAt); err != nil {+ return nil, "", stacktrace.Propagate(err, "")+ }+ items = append(items, item)+ }+ 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.MessageID+ items = items[:limit]+ }+ return items, nextCursor, nil+}+type notificationReadMarkerExecer interface {ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)}diff --git a/server/space/repo/read_markers_test.go b/server/space/repo/read_markers_test.gonew file mode 100644index 0000000000..c81c2a3dbd--- /dev/null+++ b/server/space/repo/read_markers_test.go@@ -0,0 +1,69 @@+package repo++import (+ "testing"++ "github.com/stretchr/testify/require"+)++func TestUnreadActivitiesAreScopedAndPaginated(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, "unread_stranger", "root", "public", "secret", "nonce", "profile")+ require.NoError(t, err)+ _, err = module.Read.DB.ExecContext(ctx, `DELETE FROM space_notification_read_markers`)+ require.NoError(t, err)+ for _, item := range []struct {+ id string+ sender string+ recipient string+ createdAt int64+ likedAt any+ }{+ {"incoming-a", bob.SpaceID, alice.SpaceID, 200, nil},+ {"incoming-b", bob.SpaceID, alice.SpaceID, 200, nil},+ {"outgoing-like", alice.SpaceID, bob.SpaceID, 100, int64(300)},+ {"outgoing", alice.SpaceID, bob.SpaceID, 400, nil},+ {"read", bob.SpaceID, alice.SpaceID, 100, nil},+ {"deleted", bob.SpaceID, alice.SpaceID, 400, nil},+ {"stranger", charlie.SpaceID, alice.SpaceID, 400, nil},+ {"other-recipient", bob.SpaceID, charlie.SpaceID, 400, nil},+ } {+ _, err = module.Messages.DB.ExecContext(ctx, `+ INSERT INTO space_messages (message_id, sender_space_id, recipient_space_id, kind,+ message_cipher, sender_encrypted_message_key, recipient_encrypted_message_key, created_at, recipient_liked_at)+ VALUES ($1, $2, $3, 'regular', $4, $5, $6, $7, $8)+ `, item.id, item.sender, item.recipient, []byte(item.id), []byte("sender-key"), []byte("recipient-key"), item.createdAt, item.likedAt)+ require.NoError(t, err)+ }+ _, err = module.Messages.DB.ExecContext(ctx, `UPDATE space_messages SET is_deleted = TRUE WHERE message_id = 'deleted'`)+ require.NoError(t, err)+ require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, alice.SpaceID, bob.SpaceID, 100))+ first, cursor, err := module.Read.ListUnreadActivities(ctx, alice.SpaceID, "", 2)+ require.NoError(t, err)+ require.Len(t, first, 2)+ require.Equal(t, "outgoing-like", first[0].MessageID)+ require.Equal(t, []byte("sender-key"), first[0].EncryptedMessageKey)+ require.Equal(t, "incoming-b", first[1].MessageID)+ require.Equal(t, []byte("recipient-key"), first[1].EncryptedMessageKey)+ require.Equal(t, []byte("incoming-b"), first[1].MessageCipher)+ require.NotEmpty(t, cursor)+ second, next, err := module.Read.ListUnreadActivities(ctx, alice.SpaceID, cursor, 2)+ require.NoError(t, err)+ require.Len(t, second, 1)+ require.Equal(t, "incoming-a", second[0].MessageID)+ require.Empty(t, next)+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, bob.OwnerID)+ require.NoError(t, err)+ hidden, _, err := module.Read.ListUnreadActivities(ctx, alice.SpaceID, "", 2)+ require.NoError(t, err)+ require.Empty(t, hidden)+ require.NoError(t, module.Friends.DeleteFriendship(ctx, alice.SpaceID, bob.SpaceID))+ _, err = module.Spaces.DB.ExecContext(ctx, `UPDATE users SET encrypted_email = '\x00'::bytea WHERE user_id = $1`, bob.OwnerID)+ require.NoError(t, err)+ hidden, _, err = module.Read.ListUnreadActivities(ctx, alice.SpaceID, "", 2)+ require.NoError(t, err)+ require.Empty(t, hidden)+}