Skip to content

armgit / ente

Public Imported from GitHub
0

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

Restore Space feed API and remove friend limit

Anand Baburajan713bc22d1b16
diff --git a/server/pkg/middleware/rate_limit.go b/server/pkg/middleware/rate_limit.go
index 244ffd86e6..66d92ac013 100644
--- a/server/pkg/middleware/rate_limit.go
+++ b/server/pkg/middleware/rate_limit.go
@@ -226,7 +226,7 @@ func (r *RateLimitMiddleware) getLimiter(reqPath string, reqMethod string) *limi
if reqPath == "/spaces/:spaceID/conversations" && reqMethod == http.MethodGet {
return r.limit60ReqPerMin
}
- if reqPath == "/spaces/:spaceID/home-posts" && reqMethod == http.MethodGet {
+ if reqPath == "/spaces/:spaceID/feed" && reqMethod == http.MethodGet {
return r.limit60ReqPerMin
}
if reqMethod == http.MethodGet && isSpaceViewerReadURLPath(reqPath) {
diff --git a/server/space/api/posts.go b/server/space/api/posts.go
index 9474047db8..48e846cafc 100644
--- a/server/space/api/posts.go
+++ b/server/space/api/posts.go
@@ -15,12 +15,12 @@ func (h *Handlers) CreatePost(c *gin.Context, space *spacerepo.SpaceRecord) {
respondJSON(c, resp, err)
}
-func (h *Handlers) ListHomePosts(c *gin.Context, space *spacerepo.SpaceRecord) {
- var req models.ListHomePostsRequest
+func (h *Handlers) ListFeed(c *gin.Context, space *spacerepo.SpaceRecord) {
+ var req models.ListFeedRequest
if !bindQuery(c, &req) {
return
}
- resp, err := h.Module.Posts.ListHomePosts(c, space, req)
+ resp, err := h.Module.Posts.ListFeed(c, space, req)
respondJSON(c, resp, err)
}
diff --git a/server/space/api/register.go b/server/space/api/register.go
index 82b517afb1..7e332a4aa3 100644
--- a/server/space/api/register.go
+++ b/server/space/api/register.go
@@ -16,7 +16,7 @@ func Register(privateAPI, publicAPI gin.IRouter, handlers *Handlers) {
spaceAPI.POST("/uploads/presign", selected(handlers.PresignUpload))
spaceAPI.GET("/unread", selected(handlers.GetUnreadStatus))
spaceAPI.POST("/posts", selected(handlers.CreatePost))
- spaceAPI.GET("/home-posts", selected(handlers.ListHomePosts))
+ spaceAPI.GET("/feed", selected(handlers.ListFeed))
spaceAPI.POST("/posts/:postID/caption", selected(handlers.UpdatePostCaption))
spaceAPI.PATCH("/posts/:postID/caption", selected(handlers.UpdatePostCaption))
spaceAPI.PUT("/posts/:postID/like", selected(handlers.LikePost))
diff --git a/server/space/controller/posts.go b/server/space/controller/posts.go
index 11de83d5a7..4e12aade0a 100644
--- a/server/space/controller/posts.go
+++ b/server/space/controller/posts.go
@@ -5,7 +5,6 @@ import (
"database/sql"
"errors"
"fmt"
- "strconv"
"strings"
"github.com/ente/museum/ente"
@@ -153,12 +152,8 @@ func (c *PostsController) List(ctx *gin.Context, req models.ListPostsRequest) (*
}, nil
}
-func (c *PostsController) ListHomePosts(ctx context.Context, viewerSpace *repo.SpaceRecord, req models.ListHomePostsRequest) (*models.HomePostPage, error) {
- syncCreatedAt, err := c.PostsRepo.CurrentDatabaseTimeMicroseconds(ctx)
- if err != nil {
- return nil, err
- }
- posts, nextCursor, err := c.PostsRepo.ListHomePosts(ctx, viewerSpace.SpaceID, req.After, req.Cursor, req.Limit)
+func (c *PostsController) ListFeed(ctx context.Context, viewerSpace *repo.SpaceRecord, req models.ListFeedRequest) (*models.PostPage, error) {
+ posts, nextCursor, err := c.PostsRepo.ListFeed(ctx, viewerSpace.SpaceID, req.Cursor, req.Limit)
if err != nil {
return nil, err
}
@@ -166,15 +161,9 @@ func (c *PostsController) ListHomePosts(ctx context.Context, viewerSpace *repo.S
if err != nil {
return nil, err
}
- syncPostID := int64(0)
- if len(posts) > 0 && posts[0].CreatedAt >= syncCreatedAt {
- syncCreatedAt = posts[0].CreatedAt
- syncPostID = posts[0].PostID
- }
- return &models.HomePostPage{
+ return &models.PostPage{
Items: items,
NextCursor: nextCursor,
- SyncCursor: strconv.FormatInt(syncCreatedAt, 10) + ":" + strconv.FormatInt(syncPostID, 10),
}, nil
}
diff --git a/server/space/controller/posts_test.go b/server/space/controller/posts_test.go
index 247df1ac57..823630bc27 100644
--- a/server/space/controller/posts_test.go
+++ b/server/space/controller/posts_test.go
@@ -3,8 +3,6 @@ package controller
import (
"crypto/sha256"
"database/sql"
- "strconv"
- "strings"
"testing"
timeutil "github.com/ente/museum/pkg/utils/time"
@@ -99,26 +97,8 @@ func TestListPostsHydratesPostAssets(t *testing.T) {
require.Equal(t, int64(123), page.Items[0].Objects[0].Size)
require.Equal(t, 1, page.Items[0].Objects[0].Position)
require.Equal(t, "bWV0YWRhdGE=", page.Items[0].Objects[0].MetadataCipher)
-}
-
-func TestListHomePostsSyncCursorUsesDatabaseTime(t *testing.T) {
- controller, repos, ctx := setupPostsControllerTest(t)
- aliceID := insertSpaceControllerUser(t, repos, "[email protected]", "alice-public")
- aliceSpace, err := testCreateSpace(ctx, repos, aliceID, "alice_home_sync", "alice-space-key", "alice-home-sync-public", "alice-home-sync-secret", "alice-home-sync-secret-nonce", "alice-profile")
- require.NoError(t, err)
-
- before, err := repos.Posts.CurrentDatabaseTimeMicroseconds(ctx)
- require.NoError(t, err)
- page, err := controller.ListHomePosts(ctx, aliceSpace, models.ListHomePostsRequest{Limit: 10})
- require.NoError(t, err)
- after, err := repos.Posts.CurrentDatabaseTimeMicroseconds(ctx)
+ feed, err := controller.ListFeed(ctx, aliceSpace, models.ListFeedRequest{Limit: 10})
require.NoError(t, err)
+ require.Equal(t, page.Items, feed.Items)
- createdAt, postID, found := strings.Cut(page.SyncCursor, ":")
- require.True(t, found)
- syncCreatedAt, err := strconv.ParseInt(createdAt, 10, 64)
- require.NoError(t, err)
- require.Equal(t, "0", postID)
- require.GreaterOrEqual(t, syncCreatedAt, before)
- require.LessOrEqual(t, syncCreatedAt, after)
}
diff --git a/server/space/models/models.go b/server/space/models/models.go
index cd6b677d56..689cc4a816 100644
--- a/server/space/models/models.go
+++ b/server/space/models/models.go
@@ -55,8 +55,7 @@ type ListPostsRequest struct {
Limit int `form:"limit"`
}
-type ListHomePostsRequest struct {
- After string `form:"after"`
+type ListFeedRequest struct {
Cursor string `form:"cursor"`
Limit int `form:"limit"`
}
@@ -401,9 +400,3 @@ type PostPage struct {
Items []PostResponse `json:"items"`
NextCursor string `json:"nextCursor,omitempty"`
}
-
-type HomePostPage struct {
- Items []PostResponse `json:"items"`
- NextCursor string `json:"nextCursor,omitempty"`
- SyncCursor string `json:"syncCursor"`
-}
diff --git a/server/space/repo/friends.go b/server/space/repo/friends.go
index 225b60610e..8aec43e2ea 100644
--- a/server/space/repo/friends.go
+++ b/server/space/repo/friends.go
@@ -4,10 +4,8 @@ import (
"context"
"database/sql"
"errors"
- "net/http"
"strings"
- "github.com/ente/museum/ente"
"github.com/ente/museum/ente/base"
"github.com/ente/stacktrace"
"github.com/lib/pq"
@@ -20,10 +18,7 @@ var (
ErrSpaceFriendRequestStale = errors.New("space friend request keys are stale")
)
-const (
- MaxFriendsPerSpace = 9
- MaxPendingFriendRequestsPerSpace = 100
-)
+const MaxPendingFriendRequestsPerSpace = 100
type friendShareMutation struct {
SpaceID string
@@ -54,26 +49,6 @@ func areMutualFriendsTx(ctx context.Context, tx *sql.Tx, firstSpaceID string, se
return alreadyFriends, nil
}
-func friendCapacityTx(ctx context.Context, tx *sql.Tx, spaceID string) (int, error) {
- var count int
- if err := tx.QueryRowContext(ctx, `
- SELECT
- (SELECT COUNT(*)
- FROM space_friend_shares s
- JOIN spaces friend_space ON friend_space.space_id = s.friend_space_id
- JOIN users friend_owner ON friend_owner.user_id = friend_space.owner_id AND friend_owner.encrypted_email IS NOT NULL
- WHERE s.space_id = $1) +
- (SELECT COUNT(*)
- FROM space_friend_requests fr
- JOIN spaces target_space ON target_space.space_id = fr.target_space_id
- JOIN users target_owner ON target_owner.user_id = target_space.owner_id AND target_owner.encrypted_email IS NOT NULL
- WHERE fr.requester_space_id = $1)
- `, spaceID).Scan(&count); err != nil {
- return 0, stacktrace.Propagate(err, "")
- }
- return count, nil
-}
-
func upsertMutualFriendSharesTx(ctx context.Context, tx *sql.Tx, first friendShareMutation, second friendShareMutation) error {
if err := upsertFriendShare(ctx, tx, first); err != nil {
return err
@@ -184,17 +159,6 @@ func (r *FriendsRepository) CreateFriendRequest(ctx context.Context, requesterID
case !errors.Is(err, sql.ErrNoRows):
return nil, false, false, stacktrace.Propagate(err, "")
}
- requesterFriendCapacity, err := friendCapacityTx(ctx, tx, requesterSpaceID)
- if err != nil {
- return nil, false, false, err
- }
- if requesterFriendCapacity >= MaxFriendsPerSpace {
- return nil, false, false, &ente.ApiError{
- Code: ente.ErrorCode("SPACE_FRIEND_LIMIT_REACHED"),
- Message: "space friend limit reached",
- HttpStatusCode: http.StatusConflict,
- }
- }
var reverse SpaceFriendRequestRecord
err = tx.QueryRowContext(ctx, `
@@ -214,17 +178,6 @@ func (r *FriendsRepository) CreateFriendRequest(ctx context.Context, requesterID
if targetCurrentVersion != reverse.RequesterKeyVersion {
return nil, false, false, sql.ErrNoRows
}
- targetFriendCapacity, err := friendCapacityTx(ctx, tx, targetSpaceID)
- if err != nil {
- return nil, false, false, err
- }
- if targetFriendCapacity > MaxFriendsPerSpace {
- return nil, false, false, &ente.ApiError{
- Code: ente.ErrorCode("SPACE_OTHER_FRIEND_LIMIT_REACHED"),
- Message: "other space friend limit reached",
- HttpStatusCode: http.StatusConflict,
- }
- }
if err := upsertMutualFriendSharesTx(ctx, tx,
friendShareMutation{
SpaceID: requesterSpaceID,
@@ -400,30 +353,6 @@ func (r *FriendsRepository) ConfirmFriendRequest(ctx context.Context, targetSpac
if err != nil {
return 0, false, err
}
- if !alreadyFriends {
- targetFriendCapacity, err := friendCapacityTx(ctx, tx, targetSpaceID)
- if err != nil {
- return 0, false, err
- }
- if targetFriendCapacity >= MaxFriendsPerSpace {
- return 0, false, &ente.ApiError{
- Code: ente.ErrorCode("SPACE_FRIEND_LIMIT_REACHED"),
- Message: "space friend limit reached",
- HttpStatusCode: http.StatusConflict,
- }
- }
- requesterFriendCapacity, err := friendCapacityTx(ctx, tx, requesterSpaceID)
- if err != nil {
- return 0, false, err
- }
- if requesterFriendCapacity > MaxFriendsPerSpace {
- return 0, false, &ente.ApiError{
- Code: ente.ErrorCode("SPACE_OTHER_FRIEND_LIMIT_REACHED"),
- Message: "other space friend limit reached",
- HttpStatusCode: http.StatusConflict,
- }
- }
- }
if err := upsertMutualFriendSharesTx(ctx, tx,
friendShareMutation{
SpaceID: targetSpaceID,
diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.go
index 1a775622dc..25d68a4fc7 100644
--- a/server/space/repo/module_test.go
+++ b/server/space/repo/module_test.go
@@ -6,7 +6,6 @@ import (
"crypto/sha256"
"database/sql"
"errors"
- "net/http"
"sort"
"strconv"
"sync"
@@ -181,7 +180,7 @@ func testConfirmFriendRequest(ctx context.Context, module *Module, _ int64, targ
return module.Friends.ConfirmFriendRequest(ctx, targetSpaceID, requestID, testSpaceBytes(targetFriendSealedSpaceKey), targetKeyVersion)
}
-func fillSpaceFriendLimit(t *testing.T, ctx context.Context, module *Module, space *SpaceRecord, prefix string, count int) {
+func addTestSpaceFriends(t *testing.T, ctx context.Context, module *Module, space *SpaceRecord, prefix string, count int) {
t.Helper()
for i := 0; i < count; i++ {
suffix := strconv.Itoa(i)
@@ -378,171 +377,57 @@ func TestCreateFriendRequestEnforcesTargetLimit(t *testing.T) {
require.True(t, created)
}
-func TestCreateFriendRequestEnforcesFriendLimit(t *testing.T) {
+func TestCreateFriendRequestsBeyondNine(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
- requesterID := insertSpaceUser(t, module, "[email protected]", "friend-limit-requester-public")
- targetID := insertSpaceUser(t, module, "[email protected]", "friend-limit-target-public")
- requesterSpace, err := testCreateSpace(ctx, module, requesterID, "friend_limit_requester", "root", "public", "secret", "nonce", "profile")
+ requesterID := insertSpaceUser(t, module, "[email protected]", "requester-public")
+ requester, err := testCreateSpace(ctx, module, requesterID, "requester", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
- targetSpace, err := testCreateSpace(ctx, module, targetID, "friend_limit_target", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- fillSpaceFriendLimit(t, ctx, module, requesterSpace, "friend_limit_member", MaxFriendsPerSpace)
-
- _, _, err = testCreateFriendRequest(ctx, module, requesterID, requesterSpace.SpaceID, targetSpace.SpaceID, "requester-share-key", requesterSpace.CurrentVersion)
- requireSpaceFriendLimitError(t, err, "SPACE_FRIEND_LIMIT_REACHED")
-}
+ addTestSpaceFriends(t, ctx, module, requester, "existing_friend", 12)
-func TestCreateFriendRequestCountsSentRequestsTowardFriendLimit(t *testing.T) {
- module := newSpaceTestModule(t)
- ctx := context.Background()
- requesterID := insertSpaceUser(t, module, "[email protected]", "pending-limit-requester-public")
- requesterSpace, err := testCreateSpace(ctx, module, requesterID, "pending_limit_requester", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
-
- for i := 0; i < MaxFriendsPerSpace+1; i++ {
+ for i := 0; i < 12; i++ {
suffix := strconv.Itoa(i)
- targetID := insertSpaceUser(t, module, "pending-limit-target-"+suffix+"@example.com", "pending-limit-target-public-"+suffix)
- targetSpace, err := testCreateSpace(ctx, module, targetID, "pending_limit_target_"+suffix, "root", "public", "secret", "nonce", "profile")
+ targetID := insertSpaceUser(t, module, "target-"+suffix+"@example.com", "target-public-"+suffix)
+ target, err := testCreateSpace(ctx, module, targetID, "target_"+suffix, "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
- _, created, err := testCreateFriendRequest(ctx, module, requesterID, requesterSpace.SpaceID, targetSpace.SpaceID, "requester-share-key", requesterSpace.CurrentVersion)
- if i == MaxFriendsPerSpace {
- requireSpaceFriendLimitError(t, err, "SPACE_FRIEND_LIMIT_REACHED")
- require.False(t, created)
- } else {
- require.NoError(t, err)
- require.True(t, created)
- }
+ _, created, err := testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, target.SpaceID, "share-key", requester.CurrentVersion)
+ require.NoError(t, err)
+ require.True(t, created)
}
+ require.Equal(t, int64(12), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE requester_space_id = $1`, requester.SpaceID))
}
-func TestCreateFriendRequestIgnoresTargetFriendLimit(t *testing.T) {
- module := newSpaceTestModule(t)
- ctx := context.Background()
- requesterID := insertSpaceUser(t, module, "[email protected]", "full-target-requester-public")
- targetID := insertSpaceUser(t, module, "[email protected]", "full-target-public")
- requesterSpace, err := testCreateSpace(ctx, module, requesterID, "full_target_requester", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- targetSpace, err := testCreateSpace(ctx, module, targetID, "full_target", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- fillSpaceFriendLimit(t, ctx, module, targetSpace, "full_target_member", MaxFriendsPerSpace)
-
- _, created, err := testCreateFriendRequest(ctx, module, requesterID, requesterSpace.SpaceID, targetSpace.SpaceID, "requester-share-key", requesterSpace.CurrentVersion)
- require.NoError(t, err)
- require.True(t, created)
-}
-
-func TestConfirmFriendRequestEnforcesFriendLimit(t *testing.T) {
- module := newSpaceTestModule(t)
- ctx := context.Background()
- requesterID := insertSpaceUser(t, module, "[email protected]", "confirm-limit-requester-public")
- targetID := insertSpaceUser(t, module, "[email protected]", "confirm-limit-target-public")
- requesterSpace, err := testCreateSpace(ctx, module, requesterID, "confirm_limit_requester", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- targetSpace, err := testCreateSpace(ctx, module, targetID, "confirm_limit_target", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- request, created, err := testCreateFriendRequest(ctx, module, requesterID, requesterSpace.SpaceID, targetSpace.SpaceID, "requester-share-key", requesterSpace.CurrentVersion)
- require.NoError(t, err)
- require.True(t, created)
- fillSpaceFriendLimit(t, ctx, module, targetSpace, "confirm_limit_member", MaxFriendsPerSpace)
-
- _, _, err = testConfirmFriendRequest(ctx, module, targetID, targetSpace.SpaceID, request.RequestID, "target-share-key", targetSpace.CurrentVersion)
- requireSpaceFriendLimitError(t, err, "SPACE_FRIEND_LIMIT_REACHED")
- require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE request_id = $1`, request.RequestID))
-}
-
-func TestConfirmFriendRequestCountsSentRequestsTowardFriendLimit(t *testing.T) {
- module := newSpaceTestModule(t)
- ctx := context.Background()
- requesterID := insertSpaceUser(t, module, "[email protected]", "confirm-pending-requester-public")
- targetID := insertSpaceUser(t, module, "[email protected]", "confirm-pending-target-public")
- pendingTargetID := insertSpaceUser(t, module, "[email protected]", "confirm-pending-other-public")
- requesterSpace, err := testCreateSpace(ctx, module, requesterID, "confirm_pending_requester", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- targetSpace, err := testCreateSpace(ctx, module, targetID, "confirm_pending_target", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- pendingTargetSpace, err := testCreateSpace(ctx, module, pendingTargetID, "confirm_pending_other", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- fillSpaceFriendLimit(t, ctx, module, targetSpace, "confirm_pending_member", MaxFriendsPerSpace-1)
- _, created, err := testCreateFriendRequest(ctx, module, targetID, targetSpace.SpaceID, pendingTargetSpace.SpaceID, "target-share-key", targetSpace.CurrentVersion)
- require.NoError(t, err)
- require.True(t, created)
- request, created, err := testCreateFriendRequest(ctx, module, requesterID, requesterSpace.SpaceID, targetSpace.SpaceID, "requester-share-key", requesterSpace.CurrentVersion)
- require.NoError(t, err)
- require.True(t, created)
-
- _, _, err = testConfirmFriendRequest(ctx, module, targetID, targetSpace.SpaceID, request.RequestID, "target-share-key", targetSpace.CurrentVersion)
- requireSpaceFriendLimitError(t, err, "SPACE_FRIEND_LIMIT_REACHED")
-}
-
-func requireSpaceFriendLimitError(t *testing.T, err error, code string) {
- t.Helper()
- var apiErr *ente.ApiError
- require.ErrorAs(t, err, &apiErr)
- require.Equal(t, ente.ErrorCode(code), apiErr.Code)
- require.Equal(t, http.StatusConflict, apiErr.HttpStatusCode)
-}
-
-func TestAcceptFriendRequestChecksOtherFriendLimit(t *testing.T) {
+func TestAcceptFriendRequestBeyondNine(t *testing.T) {
for _, operation := range []string{"confirm", "reciprocal"} {
- for _, friendCount := range []int{MaxFriendsPerSpace - 1, MaxFriendsPerSpace} {
- t.Run(operation+"/"+strconv.Itoa(friendCount), func(t *testing.T) {
- module := newSpaceTestModule(t)
- ctx := context.Background()
- requesterID := insertSpaceUser(t, module, "[email protected]", "requester-public")
- targetID := insertSpaceUser(t, module, "[email protected]", "target-public")
- requester, err := testCreateSpace(ctx, module, requesterID, "other_limit_requester", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- target, err := testCreateSpace(ctx, module, targetID, "other_limit_target", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- request, _, err := testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, target.SpaceID, "requester-share", requester.CurrentVersion)
- require.NoError(t, err)
- fillSpaceFriendLimit(t, ctx, module, requester, "other_limit_member", friendCount)
-
- var becameFriends bool
- if operation == "confirm" {
- _, becameFriends, err = module.Friends.ConfirmFriendRequest(ctx, target.SpaceID, request.RequestID, []byte("target-share"), target.CurrentVersion)
- } else {
- _, _, becameFriends, err = module.Friends.CreateFriendRequest(ctx, targetID, target.SpaceID, requester.SpaceID, []byte("target-share"), target.CurrentVersion)
- }
-
- if friendCount == MaxFriendsPerSpace {
- requireSpaceFriendLimitError(t, err, "SPACE_OTHER_FRIEND_LIMIT_REACHED")
- require.False(t, becameFriends)
- require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE request_id = $1`, request.RequestID))
- require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, target.SpaceID))
- } else {
- require.NoError(t, err)
- require.True(t, becameFriends)
- require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE request_id = $1`, request.RequestID))
- require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, target.SpaceID))
- }
- require.Equal(t, int64(MaxFriendsPerSpace), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, requester.SpaceID))
- })
- }
+ t.Run(operation, func(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := context.Background()
+ requesterID := insertSpaceUser(t, module, "[email protected]", "requester-public")
+ targetID := insertSpaceUser(t, module, "[email protected]", "target-public")
+ requester, err := testCreateSpace(ctx, module, requesterID, "requester", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ target, err := testCreateSpace(ctx, module, targetID, "target", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ request, _, err := testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, target.SpaceID, "requester-share", requester.CurrentVersion)
+ require.NoError(t, err)
+ addTestSpaceFriends(t, ctx, module, requester, "requester_friend", 12)
+ addTestSpaceFriends(t, ctx, module, target, "target_friend", 12)
+
+ var becameFriends bool
+ if operation == "confirm" {
+ _, becameFriends, err = module.Friends.ConfirmFriendRequest(ctx, target.SpaceID, request.RequestID, []byte("target-share"), target.CurrentVersion)
+ } else {
+ _, _, becameFriends, err = module.Friends.CreateFriendRequest(ctx, targetID, target.SpaceID, requester.SpaceID, []byte("target-share"), target.CurrentVersion)
+ }
+ require.NoError(t, err)
+ require.True(t, becameFriends)
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE request_id = $1`, request.RequestID))
+ require.Equal(t, int64(13), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, requester.SpaceID))
+ require.Equal(t, int64(13), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, target.SpaceID))
+ })
}
}
-func TestConfirmFriendRequestAllowsNinthFriend(t *testing.T) {
- module := newSpaceTestModule(t)
- ctx := context.Background()
- requesterID := insertSpaceUser(t, module, "[email protected]", "ninth-friend-requester-public")
- targetID := insertSpaceUser(t, module, "[email protected]", "ninth-friend-target-public")
- requesterSpace, err := testCreateSpace(ctx, module, requesterID, "ninth_friend_requester", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- targetSpace, err := testCreateSpace(ctx, module, targetID, "ninth_friend_target", "root", "public", "secret", "nonce", "profile")
- require.NoError(t, err)
- fillSpaceFriendLimit(t, ctx, module, targetSpace, "ninth_friend_member", MaxFriendsPerSpace-1)
- request, created, err := testCreateFriendRequest(ctx, module, requesterID, requesterSpace.SpaceID, targetSpace.SpaceID, "requester-share-key", requesterSpace.CurrentVersion)
- require.NoError(t, err)
- require.True(t, created)
-
- _, created, err = testConfirmFriendRequest(ctx, module, targetID, targetSpace.SpaceID, request.RequestID, "target-share-key", targetSpace.CurrentVersion)
- require.NoError(t, err)
- require.True(t, created)
- require.Equal(t, int64(MaxFriendsPerSpace), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, targetSpace.SpaceID))
-}
-
func testUpdateCaption(ctx context.Context, module *Module, postID int64, _ int64, spaceID string, captionCipher *string) error {
var caption []byte
if captionCipher != nil {
@@ -2222,7 +2107,7 @@ func TestListPostsBySpaceCursorUsesCreatedAtSortOrder(t *testing.T) {
require.Equal(t, "2000:"+strconv.FormatInt(second, 10), nextCursor)
}
-func TestListHomePostsReturnsFriendLatestAndPostsAfterCursor(t *testing.T) {
+func TestListFeedCursorUsesCreatedAtSortOrder(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
@@ -2254,52 +2139,30 @@ func TestListHomePostsReturnsFriendLatestAndPostsAfterCursor(t *testing.T) {
setPostCreatedAt(t, module, 2000, second)
setPostCreatedAt(t, module, 1000, third)
- page, nextCursor, err := module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "", "", 10)
+ page, nextCursor, err := module.Posts.ListFeed(ctx, aliceSpace.SpaceID, "", 1)
require.NoError(t, err)
require.Len(t, page, 1)
- require.Equal(t, first, page[0].PostID)
- require.Equal(t, bobSpace.SpaceID, page[0].SpaceID)
+ require.Equal(t, ownPost, page[0].PostID)
+ require.Equal(t, aliceSpace.SpaceID, page[0].SpaceID)
require.False(t, page[0].ViewerLiked)
- require.Empty(t, nextCursor)
+ require.Equal(t, "5000:"+strconv.FormatInt(ownPost, 10), nextCursor)
- page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "1500:0", "", 10)
- require.NoError(t, err)
- require.Len(t, page, 2)
- require.Equal(t, first, page[0].PostID)
- require.Equal(t, second, page[1].PostID)
- require.Empty(t, nextCursor)
-
- after := "1000:" + strconv.FormatInt(third, 10)
- page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, after, "", 1)
+ page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, first, page[0].PostID)
require.Equal(t, "3000:"+strconv.FormatInt(first, 10), nextCursor)
- page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, after, nextCursor, 1)
+ page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, second, page[0].PostID)
- require.Empty(t, nextCursor)
-
- page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "3000:"+strconv.FormatInt(first, 10), "", 10)
- require.NoError(t, err)
- require.Len(t, page, 1)
- require.Equal(t, first, page[0].PostID)
- require.Empty(t, nextCursor)
-
- require.NoError(t, module.Posts.UpdateCaption(ctx, second, bobSpace.SpaceID, testSpaceBytes("updated-caption")))
- page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "1500:0", "", 10)
- require.NoError(t, err)
- require.Len(t, page, 2)
- require.Equal(t, testSpaceBytes("updated-caption"), page[1].CaptionCipher)
- require.Empty(t, nextCursor)
+ require.Equal(t, "2000:"+strconv.FormatInt(second, 10), nextCursor)
- require.NoError(t, module.Posts.DeletePost(ctx, second, bobSpace.SpaceID))
- page, nextCursor, err = module.Posts.ListHomePosts(ctx, aliceSpace.SpaceID, "1500:0", "", 10)
+ page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
- require.Equal(t, first, page[0].PostID)
+ require.Equal(t, third, page[0].PostID)
require.Empty(t, nextCursor)
}
diff --git a/server/space/repo/posts.go b/server/space/repo/posts.go
index c097edb9d5..f4bdeb84b9 100644
--- a/server/space/repo/posts.go
+++ b/server/space/repo/posts.go
@@ -15,14 +15,6 @@ const MaxPostsPerSpace = 250
var ErrSpacePostLimitReached = errors.New("space post limit reached")
-func (r *PostsRepository) CurrentDatabaseTimeMicroseconds(ctx context.Context) (int64, error) {
- var currentTime int64
- if err := r.DB.QueryRowContext(ctx, `SELECT now_utc_micro_seconds()`).Scan(&currentTime); err != nil {
- return 0, stacktrace.Propagate(err, "")
- }
- return currentTime, nil
-}
-
func (r *PostsRepository) CountPosts(ctx context.Context, spaceID string) (int64, error) {
var count int64
if err := r.DB.QueryRowContext(ctx, `
@@ -187,41 +179,33 @@ func (r *PostsRepository) ListPostsBySpace(ctx context.Context, spaceID string,
return out, nextCursor, nil
}
-func (r *PostsRepository) ListHomePosts(ctx context.Context, viewerSpaceID string, after string, cursor string, limit int) ([]SpacePostRecord, string, error) {
+func (r *PostsRepository) ListFeed(ctx context.Context, viewerSpaceID string, cursor string, limit int) ([]SpacePostRecord, string, error) {
limit = optionalInt(limit, 25)
if limit > 100 {
limit = 100
}
args := []any{viewerSpaceID}
query := postRecordSelectSQL(`
- EXISTS (
+ 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_posts p
- JOIN space_friend_shares fs ON fs.friend_space_id = $1 AND fs.space_id = p.space_id
+ ) END`) + `
+ FROM (
+ SELECT $1::TEXT AS space_id
+ UNION ALL
+ SELECT space_id FROM space_friend_shares WHERE friend_space_id = $1
+ ) accessible_spaces
+ JOIN space_posts p ON p.space_id = accessible_spaces.space_id
JOIN spaces w ON w.space_id = p.space_id
` + spaceActorAvatarJoin("w", "w_avatar") + `
JOIN users u ON u.user_id = w.owner_id AND u.encrypted_email IS NOT NULL
- WHERE p.is_deleted = FALSE
- AND (
- NOT EXISTS (
- SELECT 1 FROM space_posts newer
- WHERE newer.space_id = p.space_id
- AND newer.is_deleted = FALSE
- AND (newer.created_at, newer.post_id) > (p.created_at, p.post_id)
- )`
- if afterCreatedAt, afterPostID, ok := parsePostBoundary(after); ok {
- args = append(args, afterCreatedAt, afterPostID)
- query += ` OR (p.created_at, p.post_id) > ($2, $3)`
- }
- query += `)`
+ WHERE p.is_deleted = FALSE`
if cursorCreatedAt, cursorPostID, ok := parsePostCursor(cursor); ok {
args = append(args, cursorCreatedAt, cursorPostID)
- query += ` AND (p.created_at, p.post_id) < ($` + strconv.Itoa(len(args)-1) + `, $` + strconv.Itoa(len(args)) + `)`
+ query += ` AND (p.created_at, p.post_id) < ($2, $3)`
}
args = append(args, limit+1)
query += ` ORDER BY p.created_at DESC, p.post_id DESC LIMIT $` + strconv.Itoa(len(args))
@@ -410,14 +394,6 @@ func scanPostRecord(scanner interface{ Scan(dest ...any) error }) (*SpacePostRec
}
func parsePostCursor(cursor string) (int64, int64, bool) {
- return parsePostPosition(cursor, false)
-}
-
-func parsePostBoundary(cursor string) (int64, int64, bool) {
- return parsePostPosition(cursor, true)
-}
-
-func parsePostPosition(cursor string, allowZeroPostID bool) (int64, int64, bool) {
createdAtText, postIDText, ok := strings.Cut(strings.TrimSpace(cursor), ":")
if !ok {
return 0, 0, false
@@ -427,7 +403,7 @@ func parsePostPosition(cursor string, allowZeroPostID bool) (int64, int64, bool)
return 0, 0, false
}
postID, err := strconv.ParseInt(postIDText, 10, 64)
- if err != nil || postID < 0 || (!allowZeroPostID && postID == 0) {
+ if err != nil || postID <= 0 {
return 0, 0, false
}
return createdAt, postID, true