Skip to content

armgit / ente

Public Imported from GitHub
0

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

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.go
index 54eef7198d..734f82cca6 100644
--- a/server/space/api/notifications_test.go
+++ b/server/space/api/notifications_test.go
@@ -2,6 +2,7 @@ package api
import (
"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.go
index ba6f51fa81..4f229926ec 100644
--- a/server/space/api/read_markers.go
+++ b/server/space/api/read_markers.go
@@ -1,10 +1,20 @@
package api
import (
+ "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.go
index 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.go
index 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.go
index 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.go
index 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 position
FROM 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_id
JOIN ranked sample ON sample.kind = page.kind AND sample.group_id = page.group_id
AND sample.position <= CASE WHEN page.kind = 'post_like' THEN 2 ELSE 1 END
JOIN spaces actor ON actor.space_id = sample.actor_space_id
diff --git a/server/space/repo/notifications_test.go b/server/space/repo/notifications_test.go
index 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.go
index 195840e975..607c9f19bb 100644
--- a/server/space/repo/read_markers.go
+++ b/server/space/repo/read_markers.go
@@ -3,12 +3,73 @@ package repo
import (
"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.go
new file mode 100644
index 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)
+}