diff --git a/internal/markdown/markdown.go b/internal/markdown/markdown.go index e43b3f95..e7291ce9 100644 --- a/internal/markdown/markdown.go +++ b/internal/markdown/markdown.go @@ -3,6 +3,7 @@ package markdown import ( "bytes" "cmp" + "net/url" "slices" "strings" @@ -13,17 +14,26 @@ import ( "github.com/yuin/goldmark/parser" "github.com/yuin/goldmark/text" + "github.com/usememos/memos/internal/base" mast "github.com/usememos/memos/internal/markdown/ast" "github.com/usememos/memos/internal/markdown/extensions" "github.com/usememos/memos/internal/markdown/renderer" storepb "github.com/usememos/memos/proto/gen/store" ) +// ManagedAttachmentReference is an attachment URL embedded using Markdown image syntax. +type ManagedAttachmentReference struct { + UID string +} + // ExtractedData contains all metadata extracted from markdown in a single pass. type ExtractedData struct { - Tags []string - Mentions []string - Property *storepb.MemoPayload_Property + Tags []string + Mentions []string + ImageDestinations []string + ManagedAttachmentReferences []ManagedAttachmentReference + InvalidManagedAttachmentReferences []string + Property *storepb.MemoPayload_Property } // Service handles markdown metadata extraction. @@ -402,9 +412,11 @@ func (s *service) ExtractAll(content []byte) (*ExtractedData, error) { } data := &ExtractedData{ - Tags: []string{}, - Mentions: []string{}, - Property: &storepb.MemoPayload_Property{}, + Tags: []string{}, + Mentions: []string{}, + ImageDestinations: []string{}, + ManagedAttachmentReferences: []ManagedAttachmentReference{}, + Property: &storepb.MemoPayload_Property{}, } firstBlockChecked := false @@ -420,6 +432,24 @@ func (s *service) ExtractAll(content []byte) (*ExtractedData, error) { if mentionNode, ok := n.(*mast.MentionNode); ok { data.Mentions = append(data.Mentions, string(mentionNode.Username)) } + if imageNode, ok := n.(*gast.Image); ok { + destination := string(imageNode.Destination) + data.ImageDestinations = append(data.ImageDestinations, destination) + uid, managed, valid := ParseManagedAttachmentImageURL(destination) + if managed && !valid { + data.InvalidManagedAttachmentReferences = append(data.InvalidManagedAttachmentReferences, string(imageNode.Destination)) + } else if managed { + data.ManagedAttachmentReferences = append(data.ManagedAttachmentReferences, ManagedAttachmentReference{UID: uid}) + } + } + if raw, ok := extractRawHTML(n, content); ok { + if strings.Contains(raw, "/file/attachments/") { + // Managed attachment URLs are deliberately supported only through + // Markdown image nodes. Raw HTML would require a second, security- + // sensitive HTML parser to enforce equivalent URL rules. + data.InvalidManagedAttachmentReferences = append(data.InvalidManagedAttachmentReferences, raw) + } + } // Check if the first block-level child of the document is an H1 heading. if !firstBlockChecked && n.Parent() != nil && n.Parent().Kind() == gast.KindDocument { @@ -458,10 +488,65 @@ func (s *service) ExtractAll(content []byte) (*ExtractedData, error) { // Deduplicate tags while preserving original case data.Tags = uniquePreserveCase(data.Tags) data.Mentions = uniquePreserveCase(data.Mentions) + data.ManagedAttachmentReferences = uniqueManagedAttachmentReferences(data.ManagedAttachmentReferences) + data.InvalidManagedAttachmentReferences = uniquePreserveCase(data.InvalidManagedAttachmentReferences) return data, nil } +func extractRawHTML(node gast.Node, source []byte) (string, bool) { + switch node := node.(type) { + case *gast.RawHTML: + return string(node.Segments.Value(source)), true + case *gast.HTMLBlock: + raw := append([]byte(nil), node.Lines().Value(source)...) + if node.HasClosure() { + raw = append(raw, node.ClosureLine.Value(source)...) + } + return string(raw), true + default: + return "", false + } +} + +// ParseManagedAttachmentImageURL parses a same-origin relative managed image URL. +// Absolute URL origin matching is intentionally left to callers that know the +// configured instance URL. +func ParseManagedAttachmentImageURL(raw string) (uid string, managed, valid bool) { + parsed, err := url.Parse(raw) + if err != nil || parsed.IsAbs() || parsed.Host != "" { + return "", false, false + } + if !strings.HasPrefix(parsed.Path, "/file/attachments/") { + return "", false, false + } + if parsed.RawQuery != "" || parsed.Fragment != "" || parsed.RawPath != "" || strings.Contains(parsed.EscapedPath(), "%") { + return "", true, false + } + + parts := strings.Split(strings.TrimPrefix(parsed.Path, "/file/attachments/"), "/") + if (len(parts) != 1 && len(parts) != 2) || !base.UIDMatcher.MatchString(parts[0]) { + return "", true, false + } + if len(parts) == 2 && parts[1] == "" { + return "", true, false + } + return parts[0], true, true +} + +func uniqueManagedAttachmentReferences(references []ManagedAttachmentReference) []ManagedAttachmentReference { + seen := make(map[string]struct{}, len(references)) + result := make([]ManagedAttachmentReference, 0, len(references)) + for _, reference := range references { + if _, ok := seen[reference.UID]; ok { + continue + } + seen[reference.UID] = struct{}{} + result = append(result, reference) + } + return result +} + // RenameTag renames all occurrences of oldTag to newTag in content. func (s *service) RenameTag(content []byte, oldTag, newTag string) (string, error) { root, err := s.parse(content) diff --git a/internal/markdown/markdown_test.go b/internal/markdown/markdown_test.go index 6b742d5e..1a26356c 100644 --- a/internal/markdown/markdown_test.go +++ b/internal/markdown/markdown_test.go @@ -361,6 +361,96 @@ func TestExtractAllMentions(t *testing.T) { assert.Empty(t, data.Mentions) } +func TestExtractAllManagedAttachmentImages(t *testing.T) { + svc := NewService() + data, err := svc.ExtractAll([]byte(strings.Join([]string{ + "![canonical](/file/attachments/image-one)", + "![legacy](/file/attachments/image-two/photo.png)", + "![duplicate](/file/attachments/image-one)", + "![reference][managed-image]", + "", + "[managed-image]: /file/attachments/image-three", + "![external](https://example.com/file/attachments/external)", + "`![code](/file/attachments/code-image)`", + }, "\n"))) + require.NoError(t, err) + require.Equal(t, []ManagedAttachmentReference{{UID: "image-one"}, {UID: "image-two"}, {UID: "image-three"}}, data.ManagedAttachmentReferences) + require.Empty(t, data.InvalidManagedAttachmentReferences) +} + +func TestExtractAllRejectsMalformedManagedAttachmentImages(t *testing.T) { + svc := NewService() + data, err := svc.ExtractAll([]byte(strings.Join([]string{ + "![query](/file/attachments/image-one?share_token=secret)", + "![encoded](/file/attachments/%69mage-two)", + "![extra](/file/attachments/image-three/file/extra)", + ``, + }, "\n"))) + require.NoError(t, err) + require.Empty(t, data.ManagedAttachmentReferences) + require.Len(t, data.InvalidManagedAttachmentReferences, 4) +} + +func TestExtractAllRejectsManagedAttachmentReferencesInRawHTML(t *testing.T) { + svc := NewService() + tests := []struct { + name string + content string + }{ + { + name: "inline HTML", + content: `before after`, + }, + { + name: "HTML block", + content: strings.Join([]string{ + "
", + ` `, + "
", + }, "\n"), + }, + { + name: "self-closing HTML block", + content: strings.Join([]string{ + ``, + }, "\n"), + }, + { + name: "HTML block closure line", + content: strings.Join([]string{ + "
",
+				"content",
+				`
`, + }, "\n"), + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + data, err := svc.ExtractAll([]byte(test.content)) + require.NoError(t, err) + require.Empty(t, data.ManagedAttachmentReferences) + require.Len(t, data.InvalidManagedAttachmentReferences, 1) + }) + } +} + +func TestExtractAllIgnoresManagedAttachmentReferencesInCode(t *testing.T) { + svc := NewService() + data, err := svc.ExtractAll([]byte(strings.Join([]string{ + "``", + "", + "```html", + ``, + "```", + }, "\n"))) + require.NoError(t, err) + require.Empty(t, data.ManagedAttachmentReferences) + require.Empty(t, data.InvalidManagedAttachmentReferences) +} + func TestExtractAllMentionSyntaxAndContexts(t *testing.T) { svc := NewService(WithTagExtension(), WithMentionExtension()) tests := []struct { diff --git a/server/access/memo.go b/server/access/memo.go new file mode 100644 index 00000000..18ac182d --- /dev/null +++ b/server/access/memo.go @@ -0,0 +1,131 @@ +// Package access defines transport-independent resource authorization policies +// shared by the server's API and HTTP adapters. +package access + +import "github.com/usememos/memos/store" + +// MemoReadDenial describes why a memo read was rejected. +type MemoReadDenial int + +const ( + // MemoReadDenialNone means the read is allowed. + MemoReadDenialNone MemoReadDenial = iota + // MemoReadDenialNotFound hides missing, archived, and invalid memo state. + MemoReadDenialNotFound + // MemoReadDenialUnauthenticated means the resource requires a signed-in user. + MemoReadDenialUnauthenticated + // MemoReadDenialPermission means the signed-in user cannot read the resource. + MemoReadDenialPermission +) + +// MemoReadClass describes whether the resource is anonymously readable. +type MemoReadClass int + +const ( + // MemoReadClassPrivate is for owner, authenticated, or share-token reads. + MemoReadClassPrivate MemoReadClass = iota + // MemoReadClassPublic is for resources currently readable without credentials. + MemoReadClassPublic +) + +// MemoReadDecision is the outcome of evaluating memo read access. +type MemoReadDecision struct { + Denial MemoReadDenial + Class MemoReadClass +} + +// Allowed reports whether the read is permitted. +func (d MemoReadDecision) Allowed() bool { + return d.Denial == MemoReadDenialNone +} + +// CheckMemoRead evaluates access to memo. If parent is non-nil, both the comment +// memo and its parent must be readable. A share grants access only to the exact, +// non-comment memo identified by sharedMemoID. +func CheckMemoRead(memo, parent *store.Memo, viewer *store.User, allowAnonymous bool, sharedMemoID *int32) MemoReadDecision { + if memo == nil { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + + if parent == nil { + shareApplies := sharedMemoID != nil && memo.ParentUID == nil && memo.ID == *sharedMemoID + return checkMemo(memo, viewer, allowAnonymous, shareApplies) + } + + // A token for a parent never grants access to its comments, and legacy + // comment shares never bypass the parent policy. A comment's visibility is + // derived from its parent so stale denormalized visibility values cannot + // leak or hide comments after the parent visibility changes. + commentState := checkCommentState(memo, viewer) + if !commentState.Allowed() { + return commentState + } + parentDecision := checkMemo(parent, viewer, allowAnonymous, false) + if !parentDecision.Allowed() { + return parentDecision + } + if commentState.Class == MemoReadClassPrivate { + return MemoReadDecision{Class: MemoReadClassPrivate} + } + return parentDecision +} + +func checkCommentState(memo *store.Memo, viewer *store.User) MemoReadDecision { + if memo == nil { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if memo.RowStatus == store.Archived { + if viewer != nil && viewer.ID == memo.CreatorID { + return MemoReadDecision{Class: MemoReadClassPrivate} + } + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if memo.RowStatus != store.Normal { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + return MemoReadDecision{Class: MemoReadClassPublic} +} + +func checkMemo(memo *store.Memo, viewer *store.User, allowAnonymous, shareApplies bool) MemoReadDecision { + if memo == nil { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if memo.RowStatus == store.Archived { + if viewer != nil && viewer.ID == memo.CreatorID { + return MemoReadDecision{Class: MemoReadClassPrivate} + } + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if memo.RowStatus != store.Normal { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if shareApplies { + return MemoReadDecision{Class: MemoReadClassPrivate} + } + + switch memo.Visibility { + case store.Public: + if allowAnonymous { + return MemoReadDecision{Class: MemoReadClassPublic} + } + if viewer != nil { + return MemoReadDecision{Class: MemoReadClassPrivate} + } + return MemoReadDecision{Denial: MemoReadDenialUnauthenticated} + case store.Protected: + if viewer != nil { + return MemoReadDecision{Class: MemoReadClassPrivate} + } + return MemoReadDecision{Denial: MemoReadDenialUnauthenticated} + case store.Private: + if viewer == nil { + return MemoReadDecision{Denial: MemoReadDenialUnauthenticated} + } + if viewer.ID != memo.CreatorID { + return MemoReadDecision{Denial: MemoReadDenialPermission} + } + return MemoReadDecision{Class: MemoReadClassPrivate} + default: + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } +} diff --git a/server/access/memo_test.go b/server/access/memo_test.go new file mode 100644 index 00000000..73a19b52 --- /dev/null +++ b/server/access/memo_test.go @@ -0,0 +1,55 @@ +package access + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestCheckMemoRead(t *testing.T) { + owner := &store.User{ID: 1} + other := &store.User{ID: 2, Role: store.RoleAdmin} + public := &store.Memo{ID: 1, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Public} + private := &store.Memo{ID: 2, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Private} + + require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoRead(public, nil, nil, true, nil)) + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(public, nil, nil, false, nil).Denial) + require.Equal(t, MemoReadDecision{Class: MemoReadClassPrivate}, CheckMemoRead(private, nil, owner, true, nil)) + require.Equal(t, MemoReadDenialPermission, CheckMemoRead(private, nil, other, true, nil).Denial) + + shareID := private.ID + require.Equal(t, MemoReadDecision{Class: MemoReadClassPrivate}, CheckMemoRead(private, nil, nil, false, &shareID)) +} + +func TestCheckMemoReadCommentRequiresParentAndRejectsShares(t *testing.T) { + owner := &store.User{ID: 1} + parentUID := "parent" + comment := &store.Memo{ID: 2, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Public, ParentUID: &parentUID} + parent := &store.Memo{ID: 1, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Private} + + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(comment, parent, nil, true, nil).Denial) + + commentShareID := comment.ID + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(comment, parent, nil, true, &commentShareID).Denial) + parentShareID := parent.ID + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(comment, parent, nil, true, &parentShareID).Denial) + require.True(t, CheckMemoRead(comment, parent, owner, true, nil).Allowed()) + + // Parent visibility is authoritative even if the denormalized comment value + // has not been synchronized yet. + comment.Visibility = store.Private + parent.Visibility = store.Public + require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoRead(comment, parent, nil, true, nil)) +} + +func TestCheckMemoReadArchivedAndUnknownStateFailClosed(t *testing.T) { + owner := &store.User{ID: 1} + archived := &store.Memo{ID: 1, CreatorID: owner.ID, RowStatus: store.Archived, Visibility: store.Public} + require.Equal(t, MemoReadDenialNotFound, CheckMemoRead(archived, nil, nil, true, nil).Denial) + require.Equal(t, MemoReadDecision{Class: MemoReadClassPrivate}, CheckMemoRead(archived, nil, owner, true, nil)) + + unknown := &store.Memo{ID: 2, CreatorID: owner.ID, RowStatus: store.RowStatus("UNKNOWN"), Visibility: store.Public} + require.Equal(t, MemoReadDenialNotFound, CheckMemoRead(unknown, nil, owner, true, nil).Denial) +} diff --git a/server/router/api/v1/acl_config.go b/server/router/api/v1/acl_config.go index a9233cbc..449ea86b 100644 --- a/server/router/api/v1/acl_config.go +++ b/server/router/api/v1/acl_config.go @@ -33,9 +33,13 @@ var PublicMethods = map[string]struct{}{ "/memos.api.v1.MemoService/GetMemo": {}, "/memos.api.v1.MemoService/ListMemos": {}, "/memos.api.v1.MemoService/ListMemoComments": {}, + "/memos.api.v1.MemoService/ListMemoAttachments": {}, "/memos.api.v1.MemoService/GetLinkMetadata": {}, "/memos.api.v1.MemoService/BatchGetLinkMetadata": {}, + // Attachment metadata follows the visibility of its linked memo. + "/memos.api.v1.AttachmentService/GetAttachment": {}, + // Memo sharing - share-token endpoints require no authentication "/memos.api.v1.MemoService/GetSharedMemo": {}, } diff --git a/server/router/api/v1/acl_config_test.go b/server/router/api/v1/acl_config_test.go index 7da7011e..f1c67bdc 100644 --- a/server/router/api/v1/acl_config_test.go +++ b/server/router/api/v1/acl_config_test.go @@ -28,8 +28,12 @@ func TestPublicMethodsArePublic(t *testing.T) { // Memo Service "/memos.api.v1.MemoService/GetMemo", "/memos.api.v1.MemoService/ListMemos", + "/memos.api.v1.MemoService/ListMemoComments", + "/memos.api.v1.MemoService/ListMemoAttachments", "/memos.api.v1.MemoService/GetLinkMetadata", "/memos.api.v1.MemoService/BatchGetLinkMetadata", + // Attachment Service metadata follows linked memo visibility. + "/memos.api.v1.AttachmentService/GetAttachment", } for _, method := range publicMethods { @@ -126,6 +130,8 @@ func TestAuthBootstrapClassification(t *testing.T) { "/memos.api.v1.MemoService/ListMemos", "/memos.api.v1.MemoService/GetMemo", "/memos.api.v1.MemoService/ListMemoComments", + "/memos.api.v1.MemoService/ListMemoAttachments", + "/memos.api.v1.AttachmentService/GetAttachment", "/memos.api.v1.UserService/GetUser", "/memos.api.v1.UserService/ListAllUserStats", } diff --git a/server/router/api/v1/attachment_service.go b/server/router/api/v1/attachment_service.go index b8d2282c..6602fe70 100644 --- a/server/router/api/v1/attachment_service.go +++ b/server/router/api/v1/attachment_service.go @@ -142,6 +142,9 @@ func (s *APIV1Service) CreateAttachment(ctx context.Context, request *v1pb.Creat if !canModifyMemo(user, memo) { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } + if memo.CreatorID != user.ID { + return nil, status.Errorf(codes.PermissionDenied, "attachments linked at creation must be owned by the memo creator") + } create.MemoID = &memo.ID } @@ -331,6 +334,12 @@ func (s *APIV1Service) DeleteAttachment(ctx context.Context, request *v1pb.Delet if attachment == nil { return nil, status.Errorf(codes.NotFound, "attachment not found") } + if err := s.validateAttachmentDeletions(ctx, []*store.Attachment{attachment}); err != nil { + return nil, err + } + if err := s.detachAttachmentsForDeletion(ctx, []*store.Attachment{attachment}); err != nil { + return nil, err + } // Delete the attachment from the database. if err := s.Store.DeleteAttachment(ctx, &store.DeleteAttachment{ ID: attachment.ID, @@ -382,14 +391,137 @@ func (s *APIV1Service) BatchDeleteAttachments(ctx context.Context, request *v1pb } attachments = append(attachments, attachment) } - - if err := s.Store.DeleteAttachments(ctx, attachments); err != nil { - return nil, status.Errorf(codes.Internal, "failed to delete attachments: %v", err) + if err := s.validateAttachmentDeletions(ctx, attachments); err != nil { + return nil, err + } + if err := s.detachAttachmentsForDeletion(ctx, attachments); err != nil { + return nil, err + } + for _, attachment := range attachments { + if err := s.Store.DeleteAttachment(ctx, &store.DeleteAttachment{ID: attachment.ID}); err != nil { + return nil, status.Errorf(codes.Internal, "failed to delete attachment: %v", err) + } } return &emptypb.Empty{}, nil } +func (s *APIV1Service) validateAttachmentDeletions(ctx context.Context, attachments []*store.Attachment) error { + deletingUIDs := make(map[string]struct{}, len(attachments)) + creatorIDs := make(map[int32]struct{}) + for _, attachment := range attachments { + deletingUIDs[attachment.UID] = struct{}{} + if motion := getAttachmentMotionMedia(attachment); motion != nil && motion.GroupId != "" { + creatorIDs[attachment.CreatorID] = struct{}{} + } + } + + memos := make(map[int32]*store.Memo) + for _, attachment := range attachments { + if attachment.MemoID == nil { + continue + } + memo := memos[*attachment.MemoID] + if memo == nil { + var err error + memo, err = s.Store.GetMemo(ctx, &store.FindMemo{ID: attachment.MemoID}) + if err != nil { + return status.Errorf(codes.Internal, "failed to get attachment memo: %v", err) + } + if memo == nil { + return status.Errorf(codes.FailedPrecondition, "attachment memo no longer exists") + } + memos[memo.ID] = memo + } + + references, err := s.extractManagedAttachmentReferences(memo.Content) + if err != nil { + return status.Errorf(codes.FailedPrecondition, "memo contains an invalid managed attachment reference: %v", err) + } + for _, reference := range references { + if _, ok := deletingUIDs[reference.UID]; ok { + return status.Errorf(codes.FailedPrecondition, "attachment %s is referenced by memo content", reference.UID) + } + } + } + + for creatorID := range creatorIDs { + creatorAttachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{CreatorID: &creatorID, SkipDefaultLimit: true}) + if err != nil { + return status.Errorf(codes.Internal, "failed to list motion media group: %v", err) + } + groups := make(map[string][]*store.Attachment) + for _, attachment := range creatorAttachments { + motion := getAttachmentMotionMedia(attachment) + if motion != nil && motion.GroupId != "" { + groups[motion.GroupId] = append(groups[motion.GroupId], attachment) + } + } + for _, attachment := range attachments { + if attachment.CreatorID != creatorID { + continue + } + motion := getAttachmentMotionMedia(attachment) + if motion == nil || motion.GroupId == "" || len(groups[motion.GroupId]) < 2 { + continue + } + for _, groupAttachment := range groups[motion.GroupId] { + if _, ok := deletingUIDs[groupAttachment.UID]; !ok { + return status.Errorf(codes.FailedPrecondition, "motion media group %s must be deleted together", motion.GroupId) + } + } + } + } + + return nil +} + +func (s *APIV1Service) detachAttachmentsForDeletion(ctx context.Context, attachments []*store.Attachment) error { + deletingUIDs := make(map[string]struct{}, len(attachments)) + attachmentsByMemoID := make(map[int32][]*store.Attachment) + for _, attachment := range attachments { + deletingUIDs[attachment.UID] = struct{}{} + if attachment.MemoID != nil { + attachmentsByMemoID[*attachment.MemoID] = append(attachmentsByMemoID[*attachment.MemoID], attachment) + } + } + + for memoID, memoAttachments := range attachmentsByMemoID { + memo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: &memoID}) + if err != nil { + return status.Errorf(codes.Internal, "failed to recheck attachment memo: %v", err) + } + if memo == nil { + return status.Errorf(codes.FailedPrecondition, "attachment memo no longer exists") + } + references, err := s.extractManagedAttachmentReferences(memo.Content) + if err != nil { + return status.Errorf(codes.FailedPrecondition, "memo contains an invalid managed attachment reference: %v", err) + } + for _, reference := range references { + if _, ok := deletingUIDs[reference.UID]; ok { + return status.Errorf(codes.FailedPrecondition, "attachment %s is referenced by memo content", reference.UID) + } + } + removedIDs := make([]int32, 0, len(memoAttachments)) + for _, attachment := range memoAttachments { + removedIDs = append(removedIDs, attachment.ID) + } + if err := s.Store.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: memo.ID, + MemoCreatorID: memo.CreatorID, + ExpectedMemoContent: memo.Content, + RemovedAttachmentIDs: removedIDs, + }); err != nil { + if errors.Is(err, store.ErrMemoMutationConflict) { + return status.Errorf(codes.FailedPrecondition, "memo state changed: %v", err) + } + return status.Errorf(codes.Internal, "failed to detach attachments: %v", err) + } + } + return nil +} + func (s *APIV1Service) validateAttachmentFilter(ctx context.Context, filterStr string) error { if filterStr == "" { return errors.New("filter cannot be empty") @@ -410,10 +542,12 @@ func (s *APIV1Service) validateAttachmentFilter(ctx context.Context, filterStr s // For unlinked attachments (no memo), only the creator can access. // For linked attachments, access follows the memo's visibility rules. func (s *APIV1Service) checkAttachmentAccess(ctx context.Context, attachment *store.Attachment) error { - user, _ := s.fetchCurrentUser(ctx) - // For unlinked attachments, only the creator can access. if attachment.MemoID == nil { + user, err := s.fetchCurrentUser(ctx) + if err != nil { + return status.Errorf(codes.Internal, "failed to get current user") + } if user == nil { return status.Errorf(codes.Unauthenticated, "user not authenticated") } @@ -432,14 +566,5 @@ func (s *APIV1Service) checkAttachmentAccess(ctx context.Context, attachment *st return status.Errorf(codes.NotFound, "memo not found") } - if memo.Visibility == store.Public { - return nil - } - if user == nil { - return status.Errorf(codes.Unauthenticated, "user not authenticated") - } - if memo.Visibility == store.Private && memo.CreatorID != user.ID && !isSuperUser(user) { - return status.Errorf(codes.PermissionDenied, "permission denied") - } - return nil + return s.checkMemoAndParentReadAccess(ctx, memo) } diff --git a/server/router/api/v1/attachment_service_storage.go b/server/router/api/v1/attachment_service_storage.go index ea355b6f..a1738e9c 100644 --- a/server/router/api/v1/attachment_service_storage.go +++ b/server/router/api/v1/attachment_service_storage.go @@ -36,7 +36,10 @@ func convertAttachmentFromStore(attachment *store.Attachment) *v1pb.Attachment { memoName := fmt.Sprintf("%s%s", MemoNamePrefix, *attachment.MemoUID) attachmentMessage.Memo = &memoName } - if attachment.StorageType == storepb.AttachmentStorageType_EXTERNAL || attachment.StorageType == storepb.AttachmentStorageType_S3 { + // Managed storage is always addressed through the authenticated file route. + // In particular, never expose an expiring S3 presigned URL as attachment API + // metadata because it can outlive a memo visibility change. + if attachment.StorageType == storepb.AttachmentStorageType_EXTERNAL { attachmentMessage.ExternalLink = attachment.Reference } diff --git a/server/router/api/v1/attachment_service_storage_test.go b/server/router/api/v1/attachment_service_storage_test.go new file mode 100644 index 00000000..f73275ab --- /dev/null +++ b/server/router/api/v1/attachment_service_storage_test.go @@ -0,0 +1,30 @@ +package v1 + +import ( + "testing" + + "github.com/stretchr/testify/require" + + storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/store" +) + +func TestConvertAttachmentFromStoreHidesManagedStorageReference(t *testing.T) { + s3Attachment := &store.Attachment{ + UID: "s3-image", + Filename: "image.png", + Type: "image/png", + StorageType: storepb.AttachmentStorageType_S3, + Reference: "https://s3.example.com/presigned-secret", + } + require.Empty(t, convertAttachmentFromStore(s3Attachment).ExternalLink) + + externalAttachment := &store.Attachment{ + UID: "external-image", + Filename: "image.png", + Type: "image/png", + StorageType: storepb.AttachmentStorageType_EXTERNAL, + Reference: "https://cdn.example.com/image.png", + } + require.Equal(t, externalAttachment.Reference, convertAttachmentFromStore(externalAttachment).ExternalLink) +} diff --git a/server/router/api/v1/memo_attachment_service.go b/server/router/api/v1/memo_attachment_service.go index 07344769..9379bfab 100644 --- a/server/router/api/v1/memo_attachment_service.go +++ b/server/router/api/v1/memo_attachment_service.go @@ -2,14 +2,19 @@ package v1 import ( "context" + stderrors "errors" + "net/url" "slices" + "strings" "time" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" "google.golang.org/protobuf/types/known/emptypb" + "github.com/usememos/memos/internal/markdown" v1pb "github.com/usememos/memos/proto/gen/api/v1" + storepb "github.com/usememos/memos/proto/gen/store" "github.com/usememos/memos/store" ) @@ -35,10 +40,16 @@ func (s *APIV1Service) SetMemoAttachments(ctx context.Context, request *v1pb.Set if !canModifyMemo(user, memo) { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - if err := s.setMemoAttachmentsInternal(ctx, user, memo, request.Attachments); err != nil { + prepared, err := s.prepareMemoAttachments(ctx, user, memo, request.Attachments) + if err != nil { return nil, err } - if err := s.touchMemoUpdatedTimestamp(ctx, memo.ID); err != nil { + requiredAttachmentIDs, err := s.resolveMemoAttachmentReferences(memo.Content, prepared.normalized) + if err != nil { + return nil, err + } + updatedTs := time.Now().Unix() + if err := s.applyMemoMutation(ctx, memo, prepared, &store.UpdateMemo{ID: memo.ID, UpdatedTs: &updatedTs}, requiredAttachmentIDs, nil); err != nil { return nil, err } updatedMemo, parentMemo, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) @@ -50,17 +61,28 @@ func (s *APIV1Service) SetMemoAttachments(ctx context.Context, request *v1pb.Set return &emptypb.Empty{}, nil } -func (s *APIV1Service) setMemoAttachmentsInternal(ctx context.Context, user *store.User, memo *store.Memo, requestAttachments []*v1pb.Attachment) error { +type preparedMemoAttachments struct { + current []*store.Attachment + normalized []*store.Attachment + removed []*store.Attachment +} + +func (s *APIV1Service) prepareMemoAttachments( + ctx context.Context, + user *store.User, + memo *store.Memo, + requestAttachments []*v1pb.Attachment, +) (*preparedMemoAttachments, error) { currentAttachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{ MemoID: &memo.ID, }) if err != nil { - return status.Errorf(codes.Internal, "failed to list attachments") + return nil, status.Errorf(codes.Internal, "failed to list attachments") } - normalizedAttachments, err := s.normalizeMemoAttachmentRequest(ctx, user, currentAttachments, requestAttachments) + normalizedAttachments, err := s.normalizeMemoAttachmentRequest(ctx, memo, currentAttachments, requestAttachments) if err != nil { - return err + return nil, err } requestedIDs := make(map[int32]bool, len(normalizedAttachments)) @@ -68,31 +90,105 @@ func (s *APIV1Service) setMemoAttachmentsInternal(ctx context.Context, user *sto requestedIDs[attachment.ID] = true } - // Delete attachments that are not in the request. + removedAttachments := make([]*store.Attachment, 0) for _, attachment := range currentAttachments { if !requestedIDs[attachment.ID] { + if attachment.CreatorID != memo.CreatorID { + return nil, status.Errorf(codes.FailedPrecondition, "cannot remove another user's attachment from this memo") + } if attachment.CreatorID != user.ID && !isSuperUser(user) { - return status.Errorf(codes.PermissionDenied, "cannot remove another user's attachment") - } - if err = s.Store.DeleteAttachment(ctx, &store.DeleteAttachment{ - ID: int32(attachment.ID), - MemoID: &memo.ID, - }); err != nil { - return status.Errorf(codes.Internal, "failed to delete attachment") + return nil, status.Errorf(codes.PermissionDenied, "cannot remove another user's attachment") } + removedAttachments = append(removedAttachments, attachment) } } + return &preparedMemoAttachments{ + current: currentAttachments, + normalized: normalizedAttachments, + removed: removedAttachments, + }, nil +} + +func (s *APIV1Service) applyMemoMutation( + ctx context.Context, + memo *store.Memo, + prepared *preparedMemoAttachments, + memoUpdate *store.UpdateMemo, + requiredAttachmentIDs []int32, + referenceRelations *[]*store.MemoRelation, +) error { + if prepared == nil { + prepared = &preparedMemoAttachments{} + } + currentIDs := make(map[int32]struct{}, len(prepared.current)) + for _, attachment := range prepared.current { + currentIDs[attachment.ID] = struct{}{} + } + + normalizedAttachments := slices.Clone(prepared.normalized) slices.Reverse(normalizedAttachments) - // Update attachments' memo_id in the request. + bindings := make([]*store.MemoAttachmentBinding, 0, len(normalizedAttachments)) for index, attachment := range normalizedAttachments { updatedTs := time.Now().Unix() + int64(index) - if err := s.Store.UpdateAttachment(ctx, &store.UpdateAttachment{ - ID: attachment.ID, - MemoID: &memo.ID, - UpdatedTs: &updatedTs, - }); err != nil { - return status.Errorf(codes.Internal, "failed to update attachment: %v", err) + _, wasBoundToMemo := currentIDs[attachment.ID] + bindings = append(bindings, &store.MemoAttachmentBinding{ + ID: attachment.ID, + UID: attachment.UID, + UpdatedTs: updatedTs, + WasBoundToMemo: wasBoundToMemo, + }) + } + slices.SortFunc(bindings, func(a, b *store.MemoAttachmentBinding) int { + if a.ID < b.ID { + return -1 + } + if a.ID > b.ID { + return 1 + } + return 0 + }) + removedAttachmentIDs := make([]int32, 0, len(prepared.removed)) + for _, attachment := range prepared.removed { + removedAttachmentIDs = append(removedAttachmentIDs, attachment.ID) + } + if referenceRelations != nil { + relations := make([]*store.MemoRelation, 0, len(*referenceRelations)) + for _, relation := range *referenceRelations { + relations = append(relations, &store.MemoRelation{ + MemoID: memo.ID, + RelatedMemoID: relation.RelatedMemoID, + Type: relation.Type, + }) + } + referenceRelations = &relations + } + mutation := &store.MemoMutation{ + MemoID: memo.ID, + MemoCreatorID: memo.CreatorID, + ExpectedMemoContent: memo.Content, + MemoUpdate: memoUpdate, + Bindings: bindings, + RemovedAttachmentIDs: removedAttachmentIDs, + RequiredAttachmentIDs: requiredAttachmentIDs, + ReplaceReferenceRelations: referenceRelations != nil, + } + if referenceRelations != nil { + mutation.ReferenceRelations = *referenceRelations + } + if err := s.Store.ApplyMemoMutation(ctx, mutation); err != nil { + if stderrors.Is(err, store.ErrMemoMutationConflict) { + return status.Errorf(codes.FailedPrecondition, "memo state changed: %v", err) + } + return status.Errorf(codes.Internal, "failed to apply memo mutation: %v", err) + } + + // Rows are detached in the transaction above. Delete storage one at a time so + // local cleanup remains storage-first; on failure the unlinked row remains and + // the owner can safely retry deletion. + for _, attachment := range prepared.removed { + if err := s.Store.DeleteAttachment(ctx, &store.DeleteAttachment{ID: attachment.ID}); err != nil { + return status.Errorf(codes.Internal, "failed to delete attachment: %v", err) } } @@ -101,12 +197,20 @@ func (s *APIV1Service) setMemoAttachmentsInternal(ctx context.Context, user *sto func (s *APIV1Service) normalizeMemoAttachmentRequest( ctx context.Context, - user *store.User, + memo *store.Memo, currentAttachments []*store.Attachment, requestAttachments []*v1pb.Attachment, ) ([]*store.Attachment, error) { + currentByID := make(map[int32]struct{}, len(currentAttachments)) + for _, attachment := range currentAttachments { + currentByID[attachment.ID] = struct{}{} + } + requestedAttachments := make([]*store.Attachment, 0, len(requestAttachments)) for _, requestAttachment := range requestAttachments { + if requestAttachment == nil { + return nil, status.Errorf(codes.InvalidArgument, "attachment is required") + } attachmentUID, err := ExtractAttachmentUIDFromName(requestAttachment.Name) if err != nil { return nil, status.Errorf(codes.InvalidArgument, "invalid attachment name: %v", err) @@ -118,8 +222,15 @@ func (s *APIV1Service) normalizeMemoAttachmentRequest( if attachment == nil { return nil, status.Errorf(codes.NotFound, "attachment not found: %s", attachmentUID) } - if attachment.CreatorID != user.ID && !isSuperUser(user) { - return nil, status.Errorf(codes.PermissionDenied, "cannot attach another user's attachment") + _, alreadyInTarget := currentByID[attachment.ID] + if attachment.CreatorID != memo.CreatorID && !alreadyInTarget { + // Hide another user's unlinked or foreign-memo attachment from the + // caller. Admin status grants memo maintenance privileges, not the + // right to transfer attachment ownership into a different account. + return nil, status.Errorf(codes.NotFound, "attachment not found: %s", attachmentUID) + } + if attachment.MemoID != nil && !alreadyInTarget { + return nil, status.Errorf(codes.FailedPrecondition, "attachment %s is already bound to another memo", attachmentUID) } requestedAttachments = append(requestedAttachments, attachment) } @@ -184,6 +295,122 @@ func (s *APIV1Service) normalizeMemoAttachmentRequest( return normalized, nil } +func (s *APIV1Service) resolveMemoAttachmentReferences(content string, attachments []*store.Attachment) ([]int32, error) { + references, err := s.extractManagedAttachmentReferences(content) + if err != nil { + return nil, err + } + + attachmentsByUID := make(map[string]*store.Attachment, len(attachments)) + for _, attachment := range attachments { + attachmentsByUID[attachment.UID] = attachment + } + requiredAttachmentIDs := make([]int32, 0, len(references)) + for _, reference := range references { + attachment := attachmentsByUID[reference.UID] + if attachment == nil { + return nil, status.Errorf(codes.FailedPrecondition, "managed image attachment %s must be bound to the memo", reference.UID) + } + if !strings.HasPrefix(strings.ToLower(attachment.Type), "image/") { + return nil, status.Errorf(codes.InvalidArgument, "managed image attachment %s must have an image MIME type", reference.UID) + } + if attachment.StorageType == storepb.AttachmentStorageType_EXTERNAL { + return nil, status.Errorf(codes.InvalidArgument, "external attachment %s cannot be used as a managed memo image", reference.UID) + } + requiredAttachmentIDs = append(requiredAttachmentIDs, attachment.ID) + } + return requiredAttachmentIDs, nil +} + +func (s *APIV1Service) extractManagedAttachmentReferences(content string) ([]markdown.ManagedAttachmentReference, error) { + data, err := s.MarkdownService.ExtractAll([]byte(content)) + if err != nil { + return nil, status.Errorf(codes.InvalidArgument, "invalid markdown content: %v", err) + } + if len(data.InvalidManagedAttachmentReferences) > 0 { + return nil, status.Errorf(codes.InvalidArgument, "invalid managed attachment image URL: %s", data.InvalidManagedAttachmentReferences[0]) + } + references := slices.Clone(data.ManagedAttachmentReferences) + instanceURLString := "" + if s.Profile != nil { + instanceURLString = strings.TrimSpace(s.Profile.InstanceURL) + } + var instanceURL *url.URL + if instanceURLString != "" { + instanceURL, err = url.Parse(instanceURLString) + if err != nil || !instanceURL.IsAbs() || instanceURL.Host == "" { + return nil, status.Errorf(codes.Internal, "invalid configured instance URL") + } + } + for _, destination := range data.ImageDestinations { + parsed, err := url.Parse(destination) + if err != nil || (!parsed.IsAbs() && parsed.Host == "") || !strings.HasPrefix(parsed.Path, "/file/attachments/") { + continue + } + if parsed.Scheme == "" && parsed.Host != "" { + if instanceURL == nil || sameURLAuthority(parsed, instanceURL) { + return nil, status.Errorf(codes.InvalidArgument, "protocol-relative managed attachment image URLs are not allowed: %s", destination) + } + continue + } + if instanceURL == nil { + return nil, status.Errorf(codes.InvalidArgument, "absolute managed attachment image URLs require a configured instance URL") + } + if !sameURLOrigin(parsed, instanceURL) { + continue + } + relative := parsed.EscapedPath() + if parsed.RawQuery != "" { + relative += "?" + parsed.RawQuery + } + if parsed.Fragment != "" { + relative += "#" + parsed.Fragment + } + uid, managed, valid := markdown.ParseManagedAttachmentImageURL(relative) + if !managed || !valid { + return nil, status.Errorf(codes.InvalidArgument, "invalid managed attachment image URL: %s", destination) + } + references = append(references, markdown.ManagedAttachmentReference{UID: uid}) + } + + seenReferences := make(map[string]struct{}, len(references)) + uniqueReferences := make([]markdown.ManagedAttachmentReference, 0, len(references)) + for _, reference := range references { + if _, ok := seenReferences[reference.UID]; ok { + continue + } + seenReferences[reference.UID] = struct{}{} + uniqueReferences = append(uniqueReferences, reference) + } + return uniqueReferences, nil +} + +func sameURLAuthority(candidate, instance *url.URL) bool { + withScheme := *candidate + withScheme.Scheme = instance.Scheme + return sameURLOrigin(&withScheme, instance) +} + +func sameURLOrigin(a, b *url.URL) bool { + return strings.EqualFold(a.Scheme, b.Scheme) && + strings.EqualFold(a.Hostname(), b.Hostname()) && + effectiveURLPort(a) == effectiveURLPort(b) +} + +func effectiveURLPort(u *url.URL) string { + if port := u.Port(); port != "" { + return port + } + switch strings.ToLower(u.Scheme) { + case "http": + return "80" + case "https": + return "443" + default: + return "" + } +} + func allGroupMembersRequested(group []*store.Attachment, requestedNames map[string]bool) bool { if len(group) == 0 { return false @@ -210,18 +437,8 @@ func (s *APIV1Service) ListMemoAttachments(ctx context.Context, request *v1pb.Li return nil, status.Errorf(codes.NotFound, "memo not found") } - // Check memo visibility. - if memo.Visibility != store.Public { - user, err := s.fetchCurrentUser(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get user: %v", err) - } - if user == nil { - return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") - } - if memo.Visibility == store.Private && memo.CreatorID != user.ID && !isSuperUser(user) { - return nil, status.Errorf(codes.PermissionDenied, "permission denied") - } + if err := s.checkMemoAndParentReadAccess(ctx, memo); err != nil { + return nil, err } attachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{ diff --git a/server/router/api/v1/memo_relation_service.go b/server/router/api/v1/memo_relation_service.go index 382d7214..7607f37d 100644 --- a/server/router/api/v1/memo_relation_service.go +++ b/server/router/api/v1/memo_relation_service.go @@ -3,6 +3,7 @@ package v1 import ( "context" "fmt" + "time" "github.com/pkg/errors" "google.golang.org/grpc/codes" @@ -35,10 +36,12 @@ func (s *APIV1Service) SetMemoRelations(ctx context.Context, request *v1pb.SetMe if memo.CreatorID != user.ID && !isSuperUser(user) { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - if err := s.setMemoRelationsInternal(ctx, memo, request.Relations); err != nil { + relations, err := s.prepareMemoRelations(ctx, memo, request.Relations) + if err != nil { return nil, err } - if err := s.touchMemoUpdatedTimestamp(ctx, memo.ID); err != nil { + updatedTs := time.Now().Unix() + if err := s.applyMemoMutation(ctx, memo, nil, &store.UpdateMemo{ID: memo.ID, UpdatedTs: &updatedTs}, nil, &relations); err != nil { return nil, err } updatedMemo, parentMemo, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) @@ -50,17 +53,13 @@ func (s *APIV1Service) SetMemoRelations(ctx context.Context, request *v1pb.SetMe return &emptypb.Empty{}, nil } -func (s *APIV1Service) setMemoRelationsInternal(ctx context.Context, memo *store.Memo, relations []*v1pb.MemoRelation) error { - referenceType := store.MemoRelationReference - // Delete all reference relations first. - if err := s.Store.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{ - MemoID: &memo.ID, - Type: &referenceType, - }); err != nil { - return status.Errorf(codes.Internal, "failed to delete memo relation") - } - +func (s *APIV1Service) prepareMemoRelations(ctx context.Context, memo *store.Memo, relations []*v1pb.MemoRelation) ([]*store.MemoRelation, error) { + prepared := make([]*store.MemoRelation, 0, len(relations)) + seenRelatedMemoIDs := make(map[int32]struct{}, len(relations)) for _, relation := range relations { + if relation == nil || relation.RelatedMemo == nil { + return nil, status.Errorf(codes.InvalidArgument, "related memo is required") + } // Ignore reflexive relations. if buildMemoName(memo.UID) == relation.RelatedMemo.Name { continue @@ -72,22 +71,26 @@ func (s *APIV1Service) setMemoRelationsInternal(ctx context.Context, memo *store } relatedMemoUID, err := ExtractMemoUIDFromName(relation.RelatedMemo.Name) if err != nil { - return status.Errorf(codes.InvalidArgument, "invalid related memo name: %v", err) + return nil, status.Errorf(codes.InvalidArgument, "invalid related memo name: %v", err) } relatedMemo, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: &relatedMemoUID}) if err != nil { - return status.Errorf(codes.Internal, "failed to get related memo") + return nil, status.Errorf(codes.Internal, "failed to get related memo") } - if _, err := s.Store.UpsertMemoRelation(ctx, &store.MemoRelation{ + if relatedMemo == nil { + return nil, status.Errorf(codes.NotFound, "related memo not found") + } + if _, ok := seenRelatedMemoIDs[relatedMemo.ID]; ok { + continue + } + seenRelatedMemoIDs[relatedMemo.ID] = struct{}{} + prepared = append(prepared, &store.MemoRelation{ MemoID: memo.ID, RelatedMemoID: relatedMemo.ID, Type: convertMemoRelationTypeToStore(relation.Type), - }); err != nil { - return status.Errorf(codes.Internal, "failed to upsert memo relation") - } + }) } - - return nil + return prepared, nil } func (s *APIV1Service) ListMemoRelations(ctx context.Context, request *v1pb.ListMemoRelationsRequest) (*v1pb.ListMemoRelationsResponse, error) { diff --git a/server/router/api/v1/memo_service.go b/server/router/api/v1/memo_service.go index 5938b806..1bd27883 100644 --- a/server/router/api/v1/memo_service.go +++ b/server/router/api/v1/memo_service.go @@ -11,10 +11,13 @@ import ( "github.com/pkg/errors" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" "google.golang.org/protobuf/types/known/emptypb" "github.com/usememos/memos/internal/httpgetter" v1pb "github.com/usememos/memos/proto/gen/api/v1" + storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/server/access" "github.com/usememos/memos/server/runner/memopayload" "github.com/usememos/memos/store" ) @@ -37,34 +40,44 @@ func isSSESuppressed(ctx context.Context) bool { } func (s *APIV1Service) checkMemoReadAccess(ctx context.Context, memo *store.Memo) error { - if memo == nil { - return status.Errorf(codes.NotFound, "memo not found") - } + return s.checkMemoReadAccessWithParent(ctx, memo, nil) +} - // Archived memos are only visible to their creator. - if memo.RowStatus == store.Archived { - user, err := s.fetchCurrentUser(ctx) +func (s *APIV1Service) checkMemoAndParentReadAccess(ctx context.Context, memo *store.Memo) error { + var parent *store.Memo + if memo != nil && memo.ParentUID != nil { + var err error + parent, err = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) if err != nil { - return status.Errorf(codes.Internal, "failed to get user") + return status.Errorf(codes.Internal, "failed to get parent memo") } - if user == nil || memo.CreatorID != user.ID { + if parent == nil { return status.Errorf(codes.NotFound, "memo not found") } } + return s.checkMemoReadAccessWithParent(ctx, memo, parent) +} - if memo.Visibility != store.Public { - user, err := s.fetchCurrentUser(ctx) - if err != nil { - return status.Errorf(codes.Internal, "failed to get user") - } - if user == nil { - return status.Errorf(codes.Unauthenticated, "user not authenticated") - } - if memo.Visibility == store.Private && memo.CreatorID != user.ID { - return status.Errorf(codes.PermissionDenied, "permission denied") - } +func (s *APIV1Service) checkMemoReadAccessWithParent(ctx context.Context, memo, parent *store.Memo) error { + user, err := s.fetchCurrentUser(ctx) + if err != nil { + return status.Errorf(codes.Internal, "failed to get user") + } + allowAnonymous := s.Profile != nil && s.Profile.AllowAnonymous() + return memoAccessDecisionError(access.CheckMemoRead(memo, parent, user, allowAnonymous, nil)) +} + +func memoAccessDecisionError(decision access.MemoReadDecision) error { + switch decision.Denial { + case access.MemoReadDenialNone: + return nil + case access.MemoReadDenialNotFound: + return status.Errorf(codes.NotFound, "memo not found") + case access.MemoReadDenialUnauthenticated: + return status.Errorf(codes.Unauthenticated, "user not authenticated") + default: + return status.Errorf(codes.PermissionDenied, "permission denied") } - return nil } func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoRequest) (*v1pb.Memo, error) { @@ -75,6 +88,9 @@ func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoR if user == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } + if request.Memo == nil { + return nil, status.Errorf(codes.InvalidArgument, "memo is required") + } memoUID, err := ValidateAndGenerateUID(request.MemoId) if err != nil { @@ -112,6 +128,19 @@ func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoR create.Payload.Location = convertLocationToStore(request.Memo.Location) } + preparedAttachments, err := s.prepareMemoAttachments(ctx, user, create, request.Memo.Attachments) + if err != nil { + return nil, err + } + requiredAttachmentIDs, err := s.resolveMemoAttachmentReferences(create.Content, preparedAttachments.normalized) + if err != nil { + return nil, err + } + preparedRelations, err := s.prepareMemoRelations(ctx, create, request.Memo.Relations) + if err != nil { + return nil, err + } + memo, err := s.Store.CreateMemo(ctx, create) if err != nil { // Check for unique constraint violation (AIP-133 compliance) @@ -125,12 +154,14 @@ func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoR } attachments := []*store.Attachment{} - - if len(request.Memo.Attachments) > 0 { - if err := s.setMemoAttachmentsInternal(ctx, user, memo, request.Memo.Attachments); err != nil { - return nil, errors.Wrap(err, "failed to set memo attachments") + if len(preparedAttachments.normalized) > 0 || len(preparedRelations) > 0 { + var relations *[]*store.MemoRelation + if len(preparedRelations) > 0 { + relations = &preparedRelations + } + if err := s.applyMemoMutation(ctx, memo, preparedAttachments, nil, requiredAttachmentIDs, relations); err != nil { + return nil, err } - a, err := s.Store.ListAttachments(ctx, &store.FindAttachment{ MemoID: &memo.ID, }) @@ -139,11 +170,6 @@ func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoR } attachments = a } - if len(request.Memo.Relations) > 0 { - if err := s.setMemoRelationsInternal(ctx, memo, request.Memo.Relations); err != nil { - return nil, errors.Wrap(err, "failed to set memo relations") - } - } relations, err := s.loadMemoRelations(ctx, memo) if err != nil { @@ -353,21 +379,9 @@ func (s *APIV1Service) GetMemo(ctx context.Context, request *v1pb.GetMemoRequest return nil, status.Errorf(codes.NotFound, "memo not found") } - if err := s.checkMemoReadAccess(ctx, memo); err != nil { + if err := s.checkMemoAndParentReadAccess(ctx, memo); err != nil { return nil, err } - if memo.ParentUID != nil { - parentMemo, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get parent memo") - } - if parentMemo == nil { - return nil, status.Errorf(codes.NotFound, "memo not found") - } - if err := s.checkMemoReadAccess(ctx, parentMemo); err != nil { - return nil, err - } - } reactions, err := s.Store.ListReactions(ctx, &store.FindReaction{ ContentID: &request.Name, @@ -394,11 +408,24 @@ func (s *APIV1Service) GetMemo(ctx context.Context, request *v1pb.GetMemoRequest } return nil, errors.Wrap(err, "failed to convert memo") } + if memo.ParentUID != nil { + parent, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to get parent memo") + } + if parent == nil { + return nil, status.Errorf(codes.NotFound, "memo not found") + } + memoMessage.Visibility = convertVisibilityFromStore(parent.Visibility) + } return memoMessage, nil } // UpdateMemo updates an existing memo. func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoRequest) (*v1pb.Memo, error) { + if request.Memo == nil { + return nil, status.Errorf(codes.InvalidArgument, "memo is required") + } memoUID, err := ExtractMemoUIDFromName(request.Memo.Name) if err != nil { return nil, status.Errorf(codes.InvalidArgument, "invalid memo name: %v", err) @@ -430,12 +457,19 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR update := &store.UpdateMemo{ ID: memo.ID, } - var previousContent string + previousContent := memo.Content contentUpdated := false + attachmentsUpdated := false + relationsUpdated := false + nextMemo := *memo + if memo.Payload != nil { + nextMemo.Payload = &storepb.MemoPayload{} + proto.Merge(nextMemo.Payload, memo.Payload) + } + for _, path := range request.UpdateMask.Paths { if path == "content" { contentUpdated = true - previousContent = memo.Content contentLengthLimit, err := s.getContentLengthLimit(ctx) if err != nil { return nil, status.Errorf(codes.Internal, "failed to get content length limit") @@ -443,12 +477,12 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR if len(request.Memo.Content) > contentLengthLimit { return nil, status.Errorf(codes.InvalidArgument, "content too long (max %d characters)", contentLengthLimit) } - memo.Content = request.Memo.Content - if err := memopayload.RebuildMemoPayload(ctx, memo, s.MarkdownService); err != nil { + nextMemo.Content = request.Memo.Content + if err := memopayload.RebuildMemoPayload(ctx, &nextMemo, s.MarkdownService); err != nil { return nil, status.Errorf(codes.Internal, "failed to rebuild memo payload: %v", err) } - update.Content = &memo.Content - update.Payload = memo.Payload + update.Content = &nextMemo.Content + update.Payload = nextMemo.Payload } else if path == "visibility" { visibility := convertVisibilityToStore(request.Memo.Visibility) if memo.ParentUID != nil { @@ -468,6 +502,9 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR rowStatus := convertStateToStore(request.Memo.State) update.RowStatus = &rowStatus } else if path == "create_time" { + if request.Memo.CreateTime == nil || !request.Memo.CreateTime.IsValid() { + return nil, status.Errorf(codes.InvalidArgument, "create_time is invalid") + } createdTs := request.Memo.CreateTime.AsTime().Unix() update.CreatedTs = &createdTs } else if path == "update_time" { @@ -479,21 +516,58 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR } else if path == "display_time" { return nil, status.Errorf(codes.InvalidArgument, "display_time is not supported") } else if path == "location" { - payload := memo.Payload - payload.Location = convertLocationToStore(request.Memo.Location) - update.Payload = payload + if nextMemo.Payload == nil { + nextMemo.Payload = &storepb.MemoPayload{} + } + nextMemo.Payload.Location = convertLocationToStore(request.Memo.Location) + update.Payload = nextMemo.Payload } else if path == "attachments" { - if err := s.setMemoAttachmentsInternal(ctx, user, memo, request.Memo.Attachments); err != nil { - return nil, errors.Wrap(err, "failed to set memo attachments") - } + attachmentsUpdated = true } else if path == "relations" { - if err := s.setMemoRelationsInternal(ctx, memo, request.Memo.Relations); err != nil { - return nil, errors.Wrap(err, "failed to set memo relations") - } + relationsUpdated = true } } - if err = s.Store.UpdateMemo(ctx, update); err != nil { + var preparedAttachments *preparedMemoAttachments + if attachmentsUpdated { + preparedAttachments, err = s.prepareMemoAttachments(ctx, user, memo, request.Memo.Attachments) + if err != nil { + return nil, err + } + } + var preparedRelations []*store.MemoRelation + if relationsUpdated { + preparedRelations, err = s.prepareMemoRelations(ctx, memo, request.Memo.Relations) + if err != nil { + return nil, err + } + } + var requiredAttachmentIDs []int32 + if contentUpdated || attachmentsUpdated { + var finalAttachments []*store.Attachment + if preparedAttachments != nil { + finalAttachments = preparedAttachments.normalized + } else { + finalAttachments, err = s.Store.ListAttachments(ctx, &store.FindAttachment{MemoID: &memo.ID}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list attachments") + } + } + requiredAttachmentIDs, err = s.resolveMemoAttachmentReferences(nextMemo.Content, finalAttachments) + if err != nil { + return nil, err + } + } + + if contentUpdated || attachmentsUpdated || relationsUpdated { + var relations *[]*store.MemoRelation + if relationsUpdated { + relations = &preparedRelations + } + if err := s.applyMemoMutation(ctx, memo, preparedAttachments, update, requiredAttachmentIDs, relations); err != nil { + return nil, err + } + } else if err = s.Store.UpdateMemo(ctx, update); err != nil { return nil, status.Errorf(codes.Internal, "failed to update memo") } diff --git a/server/router/api/v1/memo_service_comments.go b/server/router/api/v1/memo_service_comments.go index 8f62b43a..1b435aaf 100644 --- a/server/router/api/v1/memo_service_comments.go +++ b/server/router/api/v1/memo_service_comments.go @@ -38,8 +38,11 @@ func (s *APIV1Service) CreateMemoComment(ctx context.Context, request *v1pb.Crea if user == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - if relatedMemo.Visibility == store.Private && relatedMemo.CreatorID != user.ID && !isSuperUser(user) { - return nil, status.Errorf(codes.PermissionDenied, "permission denied") + if err := s.checkMemoAndParentReadAccess(ctx, relatedMemo); err != nil { + return nil, err + } + if relatedMemo.RowStatus != store.Normal { + return nil, status.Errorf(codes.FailedPrecondition, "cannot comment on an archived memo") } if request.Comment == nil { return nil, status.Errorf(codes.InvalidArgument, "comment is required") @@ -149,16 +152,6 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM return nil, err } - currentUser, err := s.fetchCurrentUser(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get user") - } - var memoFilter string - if currentUser == nil { - memoFilter = `visibility == "PUBLIC"` - } else { - memoFilter = fmt.Sprintf(`creator_id == %d || visibility in ["PUBLIC", "PROTECTED"]`, currentUser.ID) - } memoRelationComment := store.MemoRelationComment var limit, offset int if request.PageToken != "" { @@ -172,12 +165,13 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM limit = normalizePageSize(request.PageSize) } limitPlusOne := limit + 1 + normal := store.Normal memoRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{ - RelatedMemoID: &memo.ID, - Type: &memoRelationComment, - MemoFilter: &memoFilter, - Limit: &limitPlusOne, - Offset: &offset, + RelatedMemoID: &memo.ID, + Type: &memoRelationComment, + SourceMemoRowStatus: &normal, + Limit: &limitPlusOne, + Offset: &offset, }) if err != nil { return nil, status.Errorf(codes.Internal, "failed to list memo relations") @@ -204,7 +198,7 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM for _, m := range memoRelations { memoRelationIDs = append(memoRelationIDs, m.MemoID) } - memos, err := s.Store.ListMemos(ctx, &store.FindMemo{IDList: memoRelationIDs}) + memos, err := s.Store.ListMemos(ctx, &store.FindMemo{IDList: memoRelationIDs, RowStatus: &normal}) if err != nil { return nil, status.Errorf(codes.Internal, "failed to list memos") } @@ -274,6 +268,7 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM } return nil, errors.Wrap(err, "failed to convert memo") } + memoMessage.Visibility = convertVisibilityFromStore(memo.Visibility) memosResponse = append(memosResponse, memoMessage) } diff --git a/server/router/api/v1/memo_share_service.go b/server/router/api/v1/memo_share_service.go index 80181fe0..69cdbb6a 100644 --- a/server/router/api/v1/memo_share_service.go +++ b/server/router/api/v1/memo_share_service.go @@ -40,6 +40,12 @@ func (s *APIV1Service) CreateMemoShare(ctx context.Context, request *v1pb.Create if memo == nil { return nil, status.Errorf(codes.NotFound, "memo not found") } + if memo.ParentUID != nil { + return nil, status.Errorf(codes.FailedPrecondition, "comments cannot be shared independently") + } + if memo.RowStatus != store.Normal { + return nil, status.Errorf(codes.FailedPrecondition, "only active memos can be shared") + } if memo.CreatorID != user.ID && !isSuperUser(user) { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } @@ -161,7 +167,7 @@ func (s *APIV1Service) GetSharedMemo(ctx context.Context, request *v1pb.GetShare return nil, status.Errorf(codes.Internal, "failed to get memo") } // Treat archived or missing memos the same as an invalid token — no information leakage. - if memo == nil || memo.RowStatus == store.Archived { + if memo == nil || memo.RowStatus != store.Normal || memo.ParentUID != nil { return nil, status.Errorf(codes.NotFound, "not found") } diff --git a/server/router/api/v1/memo_update_helpers.go b/server/router/api/v1/memo_update_helpers.go index 2c5f7e04..d619a940 100644 --- a/server/router/api/v1/memo_update_helpers.go +++ b/server/router/api/v1/memo_update_helpers.go @@ -3,27 +3,13 @@ package v1 import ( "context" "log/slog" - "time" "github.com/pkg/errors" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" v1pb "github.com/usememos/memos/proto/gen/api/v1" "github.com/usememos/memos/store" ) -func (s *APIV1Service) touchMemoUpdatedTimestamp(ctx context.Context, memoID int32) error { - updatedTs := time.Now().Unix() - if err := s.Store.UpdateMemo(ctx, &store.UpdateMemo{ - ID: memoID, - UpdatedTs: &updatedTs, - }); err != nil { - return status.Errorf(codes.Internal, "failed to update memo timestamp") - } - return nil -} - func (s *APIV1Service) buildUpdatedMemoState(ctx context.Context, memoID int32) (*store.Memo, *store.Memo, *v1pb.Memo, error) { memo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: &memoID}) if err != nil { @@ -57,7 +43,14 @@ func (s *APIV1Service) buildUpdatedMemoState(ctx context.Context, memoID int32) var parentMemo *store.Memo if memo.ParentUID != nil { - parentMemo, _ = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) + parentMemo, err = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) + if err != nil { + return nil, nil, nil, errors.Wrap(err, "failed to get parent memo") + } + if parentMemo == nil { + return nil, nil, nil, errors.New("parent memo not found") + } + memoMessage.Visibility = convertVisibilityFromStore(parentMemo.Visibility) } return memo, parentMemo, memoMessage, nil @@ -68,11 +61,15 @@ func (s *APIV1Service) dispatchMemoUpdatedSideEffects(ctx context.Context, memo slog.Warn("Failed to dispatch memo updated webhook", slog.Any("err", err)) } + visibility := memo.Visibility + if parentMemo != nil { + visibility = parentMemo.Visibility + } s.SSEHub.Broadcast(&SSEEvent{ Type: SSEEventMemoUpdated, Name: memoMessage.Name, Parent: memoMessage.GetParent(), - Visibility: memo.Visibility, + Visibility: visibility, CreatorID: resolveSSECreatorID(memo, parentMemo), }) } diff --git a/server/router/api/v1/test/attachment_service_test.go b/server/router/api/v1/test/attachment_service_test.go index cab31868..7e32554b 100644 --- a/server/router/api/v1/test/attachment_service_test.go +++ b/server/router/api/v1/test/attachment_service_test.go @@ -2,9 +2,14 @@ package test import ( "context" + "os" + "path/filepath" "testing" + "github.com/lithammer/shortuuid/v4" "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" "github.com/usememos/memos/internal/testutil" v1pb "github.com/usememos/memos/proto/gen/api/v1" @@ -138,6 +143,46 @@ func TestCreateAttachment(t *testing.T) { }) } +func TestAttachmentMetadataFollowsMemoVisibility(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + owner, err := ts.CreateRegularUser(ctx, "metadata-owner") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + attachment, err := ts.Service.CreateAttachment(ownerCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: "metadata.png", + Type: "image/png", + Content: []byte("metadata image"), + }}) + require.NoError(t, err) + memo, err := ts.Service.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: "public metadata", + Visibility: v1pb.Visibility_PUBLIC, + Attachments: []*v1pb.Attachment{{Name: attachment.Name}}, + }}) + require.NoError(t, err) + + _, err = ts.Service.GetAttachment(ctx, &v1pb.GetAttachmentRequest{Name: attachment.Name}) + require.NoError(t, err) + listed, err := ts.Service.ListMemoAttachments(ctx, &v1pb.ListMemoAttachmentsRequest{Name: memo.Name}) + require.NoError(t, err) + require.Len(t, listed.Attachments, 1) + + protected := store.Protected + memoID := memoIDFromName(ctx, t, ts, memo.Name) + require.NoError(t, ts.Store.UpdateMemo(ctx, &store.UpdateMemo{ID: memoID, Visibility: &protected})) + _, err = ts.Service.GetAttachment(ctx, &v1pb.GetAttachmentRequest{Name: attachment.Name}) + require.Equal(t, codes.Unauthenticated, status.Code(err)) + _, err = ts.Service.ListMemoAttachments(ctx, &v1pb.ListMemoAttachmentsRequest{Name: memo.Name}) + require.Equal(t, codes.Unauthenticated, status.Code(err)) + + archived := store.Archived + require.NoError(t, ts.Store.UpdateMemo(ctx, &store.UpdateMemo{ID: memoID, RowStatus: &archived})) + _, err = ts.Service.GetAttachment(ctx, &v1pb.GetAttachmentRequest{Name: attachment.Name}) + require.Equal(t, codes.NotFound, status.Code(err)) +} + func TestCreateAttachmentMemoPermission(t *testing.T) { ctx := context.Background() @@ -173,7 +218,7 @@ func TestCreateAttachmentMemoPermission(t *testing.T) { require.Equal(t, memoIDFromName(ctx, t, ts, memo.Name), *stored.MemoID) }) - t.Run("admin can create attachment directly linked to memo", func(t *testing.T) { + t.Run("admin cannot create an admin-owned attachment linked to another user's memo", func(t *testing.T) { ts := NewTestService(t) defer ts.Cleanup() @@ -191,7 +236,7 @@ func TestCreateAttachmentMemoPermission(t *testing.T) { }) require.NoError(t, err) - attachment, err := ts.Service.CreateAttachment(adminCtx, &v1pb.CreateAttachmentRequest{ + _, err = ts.Service.CreateAttachment(adminCtx, &v1pb.CreateAttachmentRequest{ Attachment: &v1pb.Attachment{ Filename: "admin.txt", Type: "text/plain", @@ -199,13 +244,10 @@ func TestCreateAttachmentMemoPermission(t *testing.T) { Memo: &memo.Name, }, }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + attachments, err := ts.Store.ListAttachments(ctx, &store.FindAttachment{CreatorID: &admin.ID}) require.NoError(t, err) - attachmentUID, err := apiv1.ExtractAttachmentUIDFromName(attachment.Name) - require.NoError(t, err) - stored, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &attachmentUID}) - require.NoError(t, err) - require.NotNil(t, stored.MemoID) - require.Equal(t, memoIDFromName(ctx, t, ts, memo.Name), *stored.MemoID) + require.Empty(t, attachments) }) t.Run("non-owner cannot create attachment directly linked to memo", func(t *testing.T) { @@ -369,3 +411,152 @@ func TestBatchDeleteAttachments(t *testing.T) { require.Contains(t, err.Error(), "permission denied") }) } + +func TestBatchDeleteAttachmentsStorageFailureIsRetriable(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + ctx := context.Background() + user, err := ts.CreateRegularUser(ctx, "delete_retry_user") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + + attachments := make([]*v1pb.Attachment, 0, 2) + for _, filename := range []string{"retry-one.png", "retry-two.png"} { + attachment, err := ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: filename, + Type: "image/png", + Content: []byte(filename), + }}) + require.NoError(t, err) + attachments = append(attachments, attachment) + } + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: "batch deletion retry", + Attachments: []*v1pb.Attachment{{Name: attachments[0].Name}, {Name: attachments[1].Name}}, + }}) + require.NoError(t, err) + + localPaths := make([]string, 0, len(attachments)) + for index, attachment := range attachments { + uid, err := apiv1.ExtractAttachmentUIDFromName(attachment.Name) + require.NoError(t, err) + stored, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, err) + reference := filepath.Join("batch-delete-retry", attachment.Filename) + path := filepath.Join(ts.Profile.Data, reference) + require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o700)) + require.NoError(t, os.WriteFile(path, []byte(attachment.Filename), 0o600)) + _, err = ts.Store.GetDriver().GetDB().ExecContext(ctx, + "UPDATE attachment SET storage_type = ?, reference = ? WHERE id = ?", + "LOCAL", reference, stored.ID, + ) + require.NoError(t, err, "attachment %d", index) + localPaths = append(localPaths, path) + } + + names := []string{attachments[0].Name, attachments[1].Name} + _, err = ts.Service.BatchDeleteAttachments(store.WithDeleteAttachmentStorageFailpoint(userCtx), &v1pb.BatchDeleteAttachmentsRequest{Names: names}) + require.Equal(t, codes.Internal, status.Code(err)) + for _, attachment := range attachments { + uid, err := apiv1.ExtractAttachmentUIDFromName(attachment.Name) + require.NoError(t, err) + stored, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, err) + require.NotNil(t, stored) + require.Nil(t, stored.MemoID) + } + listed, err := ts.Service.ListMemoAttachments(userCtx, &v1pb.ListMemoAttachmentsRequest{Name: memo.Name}) + require.NoError(t, err) + require.Empty(t, listed.Attachments) + + _, err = ts.Service.BatchDeleteAttachments(userCtx, &v1pb.BatchDeleteAttachmentsRequest{Names: names}) + require.NoError(t, err) + for _, path := range localPaths { + _, err := os.Stat(path) + require.ErrorIs(t, err, os.ErrNotExist) + } +} + +func TestDeleteMotionMediaGroupRequiresWholeGroup(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + ctx := context.Background() + user, err := ts.CreateRegularUser(ctx, "delete-motion-group") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + + still, err := ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: "live.jpg", + Type: "image/jpeg", + Content: []byte("still"), + MotionMedia: &v1pb.MotionMedia{ + Family: v1pb.MotionMediaFamily_APPLE_LIVE_PHOTO, + Role: v1pb.MotionMediaRole_STILL, + GroupId: "delete-live-group", + }, + }}) + require.NoError(t, err) + video, err := ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: "live.mov", + Type: "video/quicktime", + Content: []byte("video"), + MotionMedia: &v1pb.MotionMedia{ + Family: v1pb.MotionMediaFamily_APPLE_LIVE_PHOTO, + Role: v1pb.MotionMediaRole_VIDEO, + GroupId: "delete-live-group", + }, + }}) + require.NoError(t, err) + + _, err = ts.Service.DeleteAttachment(userCtx, &v1pb.DeleteAttachmentRequest{Name: still.Name}) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + _, err = ts.Service.BatchDeleteAttachments(userCtx, &v1pb.BatchDeleteAttachmentsRequest{Names: []string{still.Name, video.Name}}) + require.NoError(t, err) +} + +func TestDeleteMotionMediaGroupChecksBeyondDefaultAttachmentPage(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + ctx := context.Background() + user, err := ts.CreateRegularUser(ctx, "delete-motion-group-many") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + + still, err := ts.Store.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), + CreatorID: user.ID, + Filename: "old-live.jpg", + Type: "image/jpeg", + Payload: &storepb.AttachmentPayload{MotionMedia: &storepb.MotionMedia{ + Family: storepb.MotionMediaFamily_APPLE_LIVE_PHOTO, + Role: storepb.MotionMediaRole_STILL, + GroupId: "delete-old-live-group", + }}, + }) + require.NoError(t, err) + for i := 0; i < 100; i++ { + attachment, err := ts.Store.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: "filler.txt", Type: "text/plain", + }) + require.NoError(t, err) + updatedTs := still.UpdatedTs + int64(i) + 1 + require.NoError(t, ts.Store.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, UpdatedTs: &updatedTs})) + } + video, err := ts.Store.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), + CreatorID: user.ID, + Filename: "new-live.mov", + Type: "video/quicktime", + Payload: &storepb.AttachmentPayload{MotionMedia: &storepb.MotionMedia{ + Family: storepb.MotionMediaFamily_APPLE_LIVE_PHOTO, + Role: storepb.MotionMediaRole_VIDEO, + GroupId: "delete-old-live-group", + }}, + }) + require.NoError(t, err) + updatedTs := still.UpdatedTs + 1000 + require.NoError(t, ts.Store.UpdateAttachment(ctx, &store.UpdateAttachment{ID: video.ID, UpdatedTs: &updatedTs})) + + _, err = ts.Service.DeleteAttachment(userCtx, &v1pb.DeleteAttachmentRequest{Name: "attachments/" + video.UID}) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) +} diff --git a/server/router/api/v1/test/memo_attachment_markdown_test.go b/server/router/api/v1/test/memo_attachment_markdown_test.go new file mode 100644 index 00000000..14ff9ac7 --- /dev/null +++ b/server/router/api/v1/test/memo_attachment_markdown_test.go @@ -0,0 +1,393 @@ +package test + +import ( + "context" + "fmt" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/lithammer/shortuuid/v4" + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/fieldmaskpb" + + v1pb "github.com/usememos/memos/proto/gen/api/v1" + api "github.com/usememos/memos/server/router/api/v1" + "github.com/usememos/memos/store" +) + +func TestMemoManagedAttachmentImages(t *testing.T) { + ctx := context.Background() + + t.Run("create accepts canonical and legacy managed image URLs", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-create") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + first := createTestImageAttachment(userCtx, t, ts, "first.png") + second := createTestImageAttachment(userCtx, t, ts, "second.png") + firstUID := strings.TrimPrefix(first.Name, "attachments/") + secondUID := strings.TrimPrefix(second.Name, "attachments/") + + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![first](/file/attachments/%s)\n![second](/file/attachments/%s/second.png)", firstUID, secondUID), + Attachments: []*v1pb.Attachment{ + {Name: first.Name}, + {Name: second.Name}, + }, + Visibility: v1pb.Visibility_PRIVATE, + }}) + require.NoError(t, err) + require.Len(t, memo.Attachments, 2) + }) + + t.Run("create validates references before creating the memo", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-missing") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + + _, err = ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{ + MemoId: "managed-missing-memo", + Memo: &v1pb.Memo{ + Content: "![missing](http://localhost:8080/file/attachments/missing-image)", + Visibility: v1pb.Visibility_PRIVATE, + }, + }) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + uid := "managed-missing-memo" + stored, getErr := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &uid}) + require.NoError(t, getErr) + require.Nil(t, stored) + }) + + t.Run("managed image must have an image MIME type", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-mime") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + textAttachment, err := ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: "not-image.txt", + Type: "text/plain", + Content: []byte("not an image"), + }}) + require.NoError(t, err) + uid := strings.TrimPrefix(textAttachment.Name, "attachments/") + + _, err = ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![wrong type](/file/attachments/%s)", uid), + Attachments: []*v1pb.Attachment{{Name: textAttachment.Name}}, + }}) + require.Equal(t, codes.InvalidArgument, status.Code(err)) + }) + + t.Run("malformed managed URLs are rejected", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-malformed") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "query.png") + uid := strings.TrimPrefix(image.Name, "attachments/") + + _, err = ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![query](/file/attachments/%s?share_token=secret)", uid), + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }}) + require.Equal(t, codes.InvalidArgument, status.Code(err)) + }) + + t.Run("protocol-relative managed URLs are rejected", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-network-path") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "network-path.png") + uid := strings.TrimPrefix(image.Name, "attachments/") + + _, err = ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![network path](//localhost:8080/file/attachments/%s)", uid), + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }}) + require.Equal(t, codes.InvalidArgument, status.Code(err)) + }) + + t.Run("cross-origin protocol-relative image URLs remain external", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "external-network-path") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: "![external](//cdn.example.com/file/attachments/external-image)", + }}) + require.NoError(t, err) + require.Empty(t, memo.Attachments) + }) + + t.Run("same-origin absolute managed URL is verified and accepted", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + ts.Profile.InstanceURL = "http://localhost" + user, err := ts.CreateRegularUser(ctx, "managed-absolute") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "absolute.png") + uid := strings.TrimPrefix(image.Name, "attachments/") + + content := fmt.Sprintf("![absolute](http://localhost:80/file/attachments/%s)", uid) + _, err = ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{Content: content}}) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: content, + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }}) + require.NoError(t, err) + require.Len(t, memo.Attachments, 1) + }) + + t.Run("content validation sees attachments beyond the default page", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-many-attachments") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{Content: "many attachments"}}) + require.NoError(t, err) + memoID := memoIDFromName(ctx, t, ts, memo.Name) + + referenced, err := ts.Store.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: "referenced.png", Type: "image/png", MemoID: &memoID, + }) + require.NoError(t, err) + for i := 0; i < 100; i++ { + attachment, err := ts.Store.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: fmt.Sprintf("extra-%03d.png", i), Type: "image/png", MemoID: &memoID, + }) + require.NoError(t, err) + updatedTs := referenced.UpdatedTs + int64(i) + 1 + require.NoError(t, ts.Store.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, UpdatedTs: &updatedTs})) + } + + updated, err := ts.Service.UpdateMemo(userCtx, &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{ + Name: memo.Name, + Content: fmt.Sprintf("![oldest](/file/attachments/%s)", referenced.UID), + }, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content"}}, + }) + require.NoError(t, err) + require.Len(t, updated.Attachments, 101) + }) + + t.Run("set attachments cannot remove an image referenced by content", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-set") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "kept.png") + uid := strings.TrimPrefix(image.Name, "attachments/") + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![kept](/file/attachments/%s)", uid), + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }}) + require.NoError(t, err) + + _, err = ts.Service.SetMemoAttachments(userCtx, &v1pb.SetMemoAttachmentsRequest{Name: memo.Name}) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + attachments, listErr := ts.Service.ListMemoAttachments(userCtx, &v1pb.ListMemoAttachmentsRequest{Name: memo.Name}) + require.NoError(t, listErr) + require.Len(t, attachments.Attachments, 1) + }) + + t.Run("content and attachments are validated as one final update state", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-update") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "removed.png") + uid := strings.TrimPrefix(image.Name, "attachments/") + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![removed](/file/attachments/%s)", uid), + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }}) + require.NoError(t, err) + + updated, err := ts.Service.UpdateMemo(userCtx, &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{Name: memo.Name, Content: "image removed", Attachments: []*v1pb.Attachment{}}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"attachments", "content"}}, + }) + require.NoError(t, err) + require.Equal(t, "image removed", updated.Content) + require.Empty(t, updated.Attachments) + stored, getErr := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, getErr) + require.Nil(t, stored) + }) + + t.Run("local deletion failure leaves a detached row that can be retried", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-delete-retry") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "retry.png") + uid := strings.TrimPrefix(image.Name, "attachments/") + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: "attachment will be removed", + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }}) + require.NoError(t, err) + storedImage, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, err) + require.NotNil(t, storedImage) + localReference := "retry-delete.png" + localPath := filepath.Join(ts.Profile.Data, localReference) + require.NoError(t, os.WriteFile(localPath, []byte("local image"), 0o600)) + _, err = ts.Store.GetDriver().GetDB().ExecContext(ctx, + "UPDATE attachment SET storage_type = ?, reference = ? WHERE id = ?", + "LOCAL", localReference, storedImage.ID, + ) + require.NoError(t, err) + + _, err = ts.Service.UpdateMemo(store.WithDeleteAttachmentStorageFailpoint(userCtx), &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{Name: memo.Name, Content: "attachment removed", Attachments: []*v1pb.Attachment{}}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content", "attachments"}}, + }) + require.Equal(t, codes.Internal, status.Code(err)) + storedMemo, getErr := ts.Service.GetMemo(userCtx, &v1pb.GetMemoRequest{Name: memo.Name}) + require.NoError(t, getErr) + require.Equal(t, "attachment removed", storedMemo.Content) + storedImage, getErr = ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, getErr) + require.NotNil(t, storedImage) + require.Nil(t, storedImage.MemoID) + + _, err = ts.Service.DeleteAttachment(userCtx, &v1pb.DeleteAttachmentRequest{Name: image.Name}) + require.NoError(t, err) + _, statErr := os.Stat(localPath) + require.ErrorIs(t, statErr, os.ErrNotExist) + }) + + t.Run("failed content validation does not mutate the memo", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-update-failure") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{Content: "original"}}) + require.NoError(t, err) + + _, err = ts.Service.UpdateMemo(userCtx, &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{Name: memo.Name, Content: "![missing](/file/attachments/missing-update-image)"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content"}}, + }) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + stored, getErr := ts.Service.GetMemo(userCtx, &v1pb.GetMemoRequest{Name: memo.Name}) + require.NoError(t, getErr) + require.Equal(t, "original", stored.Content) + }) + + t.Run("delete APIs reject referenced attachments", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "managed-delete") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "referenced.png") + uid := strings.TrimPrefix(image.Name, "attachments/") + _, err = ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![referenced](/file/attachments/%s)", uid), + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }}) + require.NoError(t, err) + + _, err = ts.Service.DeleteAttachment(userCtx, &v1pb.DeleteAttachmentRequest{Name: image.Name}) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + _, err = ts.Service.BatchDeleteAttachments(userCtx, &v1pb.BatchDeleteAttachmentsRequest{Names: []string{image.Name}}) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + stored, getErr := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, getErr) + require.NotNil(t, stored) + }) +} + +func TestMemoAttachmentBindingDoesNotReparent(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "no-reparent") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + image := createTestImageAttachment(userCtx, t, ts, "bound.png") + first, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{Attachments: []*v1pb.Attachment{{Name: image.Name}}}}) + require.NoError(t, err) + second, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{Content: "second"}}) + require.NoError(t, err) + + _, err = ts.Service.SetMemoAttachments(userCtx, &v1pb.SetMemoAttachmentsRequest{ + Name: second.Name, + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + uid, err := api.ExtractAttachmentUIDFromName(image.Name) + require.NoError(t, err) + stored, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, err) + require.NotNil(t, stored) + require.NotNil(t, stored.MemoID) + require.Equal(t, memoIDFromName(ctx, t, ts, first.Name), *stored.MemoID) +} + +func TestCreateMemoDoesNotBindAnotherUsersAttachmentOrCreatePartialMemo(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + owner, err := ts.CreateRegularUser(ctx, "foreign-attachment-owner") + require.NoError(t, err) + other, err := ts.CreateRegularUser(ctx, "foreign-attachment-caller") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + otherCtx := ts.CreateUserContext(ctx, other.ID) + image := createTestImageAttachment(ownerCtx, t, ts, "foreign.png") + + _, err = ts.Service.CreateMemo(otherCtx, &v1pb.CreateMemoRequest{ + MemoId: "no-partial-foreign-memo", + Memo: &v1pb.Memo{ + Content: "foreign attachment", + Attachments: []*v1pb.Attachment{{Name: image.Name}}, + }, + }) + require.Equal(t, codes.NotFound, status.Code(err)) + uid := "no-partial-foreign-memo" + memo, getErr := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &uid}) + require.NoError(t, getErr) + require.Nil(t, memo) + attachmentUID := strings.TrimPrefix(image.Name, "attachments/") + attachment, getErr := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &attachmentUID}) + require.NoError(t, getErr) + require.NotNil(t, attachment) + require.Nil(t, attachment.MemoID) +} + +func createTestImageAttachment(ctx context.Context, t *testing.T, ts *TestService, filename string) *v1pb.Attachment { + t.Helper() + attachment, err := ts.Service.CreateAttachment(ctx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: filename, + Type: "image/png", + Content: []byte("test image"), + }}) + require.NoError(t, err) + return attachment +} diff --git a/server/router/api/v1/test/memo_attachment_service_test.go b/server/router/api/v1/test/memo_attachment_service_test.go index a715a81b..752cc349 100644 --- a/server/router/api/v1/test/memo_attachment_service_test.go +++ b/server/router/api/v1/test/memo_attachment_service_test.go @@ -6,6 +6,8 @@ import ( "testing" "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" apiv1 "github.com/usememos/memos/proto/gen/api/v1" "github.com/usememos/memos/store" @@ -273,7 +275,7 @@ func TestSetMemoAttachments(t *testing.T) { }, }) require.Error(t, err) - require.Contains(t, err.Error(), "cannot attach another user's attachment") + require.Equal(t, codes.NotFound, status.Code(err)) victimAttachments, err := ts.Service.ListMemoAttachments(victimCtx, &apiv1.ListMemoAttachmentsRequest{Name: victimMemo.Name}) require.NoError(t, err) diff --git a/server/router/api/v1/test/memo_relation_service_test.go b/server/router/api/v1/test/memo_relation_service_test.go index 98c2c565..a0092b22 100644 --- a/server/router/api/v1/test/memo_relation_service_test.go +++ b/server/router/api/v1/test/memo_relation_service_test.go @@ -5,6 +5,9 @@ import ( "testing" "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/fieldmaskpb" apiv1 "github.com/usememos/memos/proto/gen/api/v1" ) @@ -167,3 +170,44 @@ func TestSetMemoRelations(t *testing.T) { require.Contains(t, err.Error(), "not found") }) } + +func TestUpdateMemoValidatesAllRelationsBeforeMutation(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + user, err := ts.CreateRegularUser(ctx, "atomic-relation-update") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + + target, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{Content: "target"}}) + require.NoError(t, err) + replacement, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{Content: "replacement"}}) + require.NoError(t, err) + source, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "original", + Relations: []*apiv1.MemoRelation{{ + RelatedMemo: &apiv1.MemoRelation_Memo{Name: target.Name}, + Type: apiv1.MemoRelation_REFERENCE, + }}, + }}) + require.NoError(t, err) + + _, err = ts.Service.UpdateMemo(userCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{ + Name: source.Name, + Content: "must roll back", + Relations: []*apiv1.MemoRelation{ + {RelatedMemo: &apiv1.MemoRelation_Memo{Name: replacement.Name}, Type: apiv1.MemoRelation_REFERENCE}, + {RelatedMemo: &apiv1.MemoRelation_Memo{Name: "invalid-name"}, Type: apiv1.MemoRelation_REFERENCE}, + }, + }, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content", "relations"}}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err)) + + stored, err := ts.Service.GetMemo(userCtx, &apiv1.GetMemoRequest{Name: source.Name}) + require.NoError(t, err) + require.Equal(t, "original", stored.Content) + require.Len(t, stored.Relations, 1) + require.Equal(t, target.Name, stored.Relations[0].RelatedMemo.Name) +} diff --git a/server/router/api/v1/test/memo_service_test.go b/server/router/api/v1/test/memo_service_test.go index d28988ed..9e9c6ba4 100644 --- a/server/router/api/v1/test/memo_service_test.go +++ b/server/router/api/v1/test/memo_service_test.go @@ -584,6 +584,47 @@ func TestListMemoCommentsPaginates(t *testing.T) { require.Empty(t, secondPage.NextPageToken) } +func TestListMemoCommentsFiltersArchivedBeforePagination(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "comment-archive-page-owner") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + memo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "memo with archived comments", + Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + + comments := make([]*apiv1.Memo, 0, 5) + for i := 0; i < 5; i++ { + comment, err := ts.Service.CreateMemoComment(ownerCtx, &apiv1.CreateMemoCommentRequest{ + Name: memo.Name, + Comment: &apiv1.Memo{Content: fmt.Sprintf("comment %d", i)}, + }) + require.NoError(t, err) + comments = append(comments, comment) + } + for _, comment := range comments[3:] { + _, err := ts.Service.UpdateMemo(ownerCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: comment.Name, State: apiv1.State_ARCHIVED}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"state"}}, + }) + require.NoError(t, err) + } + + firstPage, err := ts.Service.ListMemoComments(ownerCtx, &apiv1.ListMemoCommentsRequest{Name: memo.Name, PageSize: 2}) + require.NoError(t, err) + require.Len(t, firstPage.Memos, 2) + require.NotEmpty(t, firstPage.NextPageToken) + secondPage, err := ts.Service.ListMemoComments(ownerCtx, &apiv1.ListMemoCommentsRequest{Name: memo.Name, PageToken: firstPage.NextPageToken}) + require.NoError(t, err) + require.Len(t, secondPage.Memos, 1) + require.Empty(t, secondPage.NextPageToken) +} + func TestCreateMemoCommentInheritsParentVisibility(t *testing.T) { ctx := context.Background() @@ -626,6 +667,41 @@ func TestCreateMemoCommentInheritsParentVisibility(t *testing.T) { require.Equal(t, codes.Unauthenticated, status.Code(err)) } +func TestCreateMemoCommentDoesNotRevealArchivedPrivateMemo(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "archived-comment-owner") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + other, err := ts.CreateRegularUser(ctx, "archived-comment-other") + require.NoError(t, err) + otherCtx := ts.CreateUserContext(ctx, other.ID) + parent, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "archived private parent", + Visibility: apiv1.Visibility_PRIVATE, + }}) + require.NoError(t, err) + _, err = ts.Service.UpdateMemo(ownerCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: parent.Name, State: apiv1.State_ARCHIVED}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"state"}}, + }) + require.NoError(t, err) + + _, err = ts.Service.CreateMemoComment(otherCtx, &apiv1.CreateMemoCommentRequest{ + Name: parent.Name, + Comment: &apiv1.Memo{Content: "should not reveal parent state"}, + }) + require.Equal(t, codes.NotFound, status.Code(err)) + + _, err = ts.Service.CreateMemoComment(ownerCtx, &apiv1.CreateMemoCommentRequest{ + Name: parent.Name, + Comment: &apiv1.Memo{Content: "owner still cannot comment"}, + }) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) +} + func TestGetMemoCommentRequiresParentReadAccess(t *testing.T) { ctx := context.Background() @@ -691,6 +767,41 @@ func TestGetMemoCommentRequiresParentReadAccess(t *testing.T) { require.Equal(t, commentName, comments.Memos[0].Name) } +func TestMemoCommentUsesCurrentParentVisibility(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "dynamic-comment-owner") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + parent, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "initially private", + Visibility: apiv1.Visibility_PRIVATE, + }}) + require.NoError(t, err) + comment, err := ts.Service.CreateMemoComment(ownerCtx, &apiv1.CreateMemoCommentRequest{ + Name: parent.Name, + Comment: &apiv1.Memo{Content: "inherits private"}, + }) + require.NoError(t, err) + require.Equal(t, apiv1.Visibility_PRIVATE, comment.Visibility) + + _, err = ts.Service.UpdateMemo(ownerCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: parent.Name, Visibility: apiv1.Visibility_PUBLIC}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}}, + }) + require.NoError(t, err) + + visibleComment, err := ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: comment.Name}) + require.NoError(t, err) + require.Equal(t, comment.Name, visibleComment.Name) + comments, err := ts.Service.ListMemoComments(ctx, &apiv1.ListMemoCommentsRequest{Name: parent.Name}) + require.NoError(t, err) + require.Len(t, comments.Memos, 1) + require.Equal(t, comment.Name, comments.Memos[0].Name) +} + // TestCreateMemoWithCustomTimestamps tests that custom timestamps can be set when creating memos and comments. // This addresses issue #5483: https://github.com/usememos/memos/issues/5483 func TestCreateMemoWithCustomTimestamps(t *testing.T) { diff --git a/server/router/api/v1/test/memo_share_service_test.go b/server/router/api/v1/test/memo_share_service_test.go index 12cb0ee0..af03a77e 100644 --- a/server/router/api/v1/test/memo_share_service_test.go +++ b/server/router/api/v1/test/memo_share_service_test.go @@ -110,7 +110,7 @@ func TestGetSharedMemo_IncludesReactions(t *testing.T) { require.Equal(t, memo.Name, sharedMemo.Reactions[0].ContentId) } -func TestGetSharedMemo_ExcludesParentAndRelations(t *testing.T) { +func TestCreateMemoShare_RejectsComment(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -143,19 +143,21 @@ func TestGetSharedMemo_ExcludesParentAndRelations(t *testing.T) { require.NotEmpty(t, regularMemo.GetParent()) require.NotEmpty(t, regularMemo.Relations) - share, err := ts.Service.CreateMemoShare(userCtx, &apiv1.CreateMemoShareRequest{ + _, err = ts.Service.CreateMemoShare(userCtx, &apiv1.CreateMemoShareRequest{ Parent: comment.Name, MemoShare: &apiv1.MemoShare{}, }) - require.NoError(t, err) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) - shareToken := share.Name[strings.LastIndex(share.Name, "/")+1:] - sharedMemo, err := ts.Service.GetSharedMemo(ctx, &apiv1.GetSharedMemoRequest{ - ShareToken: shareToken, + // Legacy rows created before this rule must not remain a bypass. + legacyShare, err := ts.Store.CreateMemoShare(ctx, &store.MemoShare{ + UID: "legacy-comment-share", + MemoID: parseMemoIDFromNameForTest(t, ts, comment.Name), + CreatorID: user.ID, }) require.NoError(t, err) - require.Empty(t, sharedMemo.GetParent()) - require.Empty(t, sharedMemo.Relations) + _, err = ts.Service.GetSharedMemo(ctx, &apiv1.GetSharedMemoRequest{ShareToken: legacyShare.UID}) + require.Equal(t, codes.NotFound, status.Code(err)) } func TestGetSharedMemo_SkipsReactionsWithMissingCreators(t *testing.T) { diff --git a/server/router/fileserver/fileserver.go b/server/router/fileserver/fileserver.go index 63c4dc1f..ad71baae 100644 --- a/server/router/fileserver/fileserver.go +++ b/server/router/fileserver/fileserver.go @@ -23,6 +23,7 @@ import ( "github.com/usememos/memos/internal/profile" "github.com/usememos/memos/internal/storage/s3" storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/server/access" "github.com/usememos/memos/server/auth" "github.com/usememos/memos/store" ) @@ -47,6 +48,9 @@ const ( // cacheMaxAge is the max-age value for Cache-Control headers (1 hour). cacheMaxAge = "public, max-age=3600" + + publicAttachmentCacheControl = "public, no-cache" + privateAttachmentCacheControl = "private, no-store" ) // xssUnsafeTypes contains MIME types that could execute scripts if served directly. @@ -120,6 +124,7 @@ func NewFileServerService(profile *profile.Profile, store *store.Store, secret s // RegisterRoutes registers HTTP file serving routes. func (s *FileServerService) RegisterRoutes(echoServer *echo.Echo) { fileGroup := echoServer.Group("/file") + fileGroup.GET("/attachments/:uid", s.serveAttachmentFile) fileGroup.GET("/attachments/:uid/:filename", s.serveAttachmentFile) fileGroup.GET("/users/:identifier/avatar", s.serveUserAvatar) } @@ -131,6 +136,7 @@ func (s *FileServerService) RegisterRoutes(echoServer *echo.Echo) { // serveAttachmentFile serves attachment binary content using native HTTP. func (s *FileServerService) serveAttachmentFile(c *echo.Context) error { ctx := c.Request().Context() + c.Response().Header().Set(echo.HeaderCacheControl, privateAttachmentCacheControl) uid := c.Param("uid") wantThumbnail := c.QueryParam("thumbnail") == "true" wantMotion := c.QueryParam("motion") == "true" @@ -146,9 +152,13 @@ func (s *FileServerService) serveAttachmentFile(c *echo.Context) error { return echo.NewHTTPError(http.StatusNotFound, "attachment not found") } - if err := s.checkAttachmentPermission(ctx, c, attachment); err != nil { + readClass, err := s.checkAttachmentPermission(ctx, c, attachment) + if err != nil { return err } + if readClass == access.MemoReadClassPublic { + c.Response().Header().Set(echo.HeaderCacheControl, publicAttachmentCacheControl) + } if wantMotion { return s.serveMotionClip(c, attachment) @@ -647,60 +657,75 @@ func (s *FileServerService) getMotionPath(attachment *store.Attachment) (string, // ============================================================================= // checkAttachmentPermission verifies the user has permission to access the attachment. -func (s *FileServerService) checkAttachmentPermission(ctx context.Context, c *echo.Context, attachment *store.Attachment) error { +func (s *FileServerService) checkAttachmentPermission(ctx context.Context, c *echo.Context, attachment *store.Attachment) (access.MemoReadClass, error) { // For unlinked attachments, only the creator can access. if attachment.MemoID == nil { user, err := s.getCurrentUser(ctx, c) if err != nil { - return echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err) + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err) } if user == nil { - return echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access") + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access") } if user.ID != attachment.CreatorID && user.Role != store.RoleAdmin { - return echo.NewHTTPError(http.StatusForbidden, "forbidden access") + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusForbidden, "forbidden access") } - return nil + return access.MemoReadClassPrivate, nil } memo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: attachment.MemoID}) if err != nil { - return echo.NewHTTPError(http.StatusInternalServerError, "failed to find memo").Wrap(err) + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to find memo").Wrap(err) } if memo == nil { - return echo.NewHTTPError(http.StatusNotFound, "memo not found") + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusNotFound, "memo not found") } - // Public-visibility attachments are served to anonymous visitors only when the - // instance allows anonymous access. On a private instance (no InstanceURL), the - // request must still resolve to an authenticated user or a valid share token below. - if memo.Visibility == store.Public && s.Profile.AllowAnonymous() { - return nil + var parent *store.Memo + if memo.ParentUID != nil { + parent, err = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) + if err != nil { + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to find parent memo").Wrap(err) + } + if parent == nil { + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusNotFound, "memo not found") + } } - // Check share token fallback: allow access if request carries a valid, non-expired share token - // that was issued for this specific memo. This covers attachment requests made from the shared - // memo page for private or protected memos. + allowAnonymous := s.Profile != nil && s.Profile.AllowAnonymous() + if decision := access.CheckMemoRead(memo, parent, nil, allowAnonymous, nil); decision.Allowed() { + return decision.Class, nil + } + + var sharedMemoID *int32 if shareToken := (*c).QueryParam("share_token"); shareToken != "" { ms, err := s.Store.GetMemoShare(ctx, &store.FindMemoShare{UID: &shareToken}) - if err == nil && ms != nil && !isMemoShareExpired(ms) && ms.MemoID == memo.ID { - return nil + if err != nil { + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get memo share").Wrap(err) + } + if ms != nil && !isMemoShareExpired(ms) { + sharedMemoID = &ms.MemoID + if decision := access.CheckMemoRead(memo, parent, nil, allowAnonymous, sharedMemoID); decision.Allowed() { + return decision.Class, nil + } } } user, err := s.getCurrentUser(ctx, c) if err != nil { - return echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err) + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err) } - if user == nil { - return echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access") + decision := access.CheckMemoRead(memo, parent, user, allowAnonymous, sharedMemoID) + switch decision.Denial { + case access.MemoReadDenialNone: + return decision.Class, nil + case access.MemoReadDenialNotFound: + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusNotFound, "memo not found") + case access.MemoReadDenialUnauthenticated: + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access") + default: + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusForbidden, "forbidden access") } - - if memo.Visibility == store.Private && user.ID != memo.CreatorID && user.Role != store.RoleAdmin { - return echo.NewHTTPError(http.StatusForbidden, "forbidden access") - } - - return nil } // getCurrentUser retrieves the current authenticated user from the request. @@ -766,7 +791,9 @@ func setSecurityHeaders(c *echo.Context) { func setMediaHeaders(c *echo.Context, contentType, originalType string) { h := c.Response().Header() h.Set(echo.HeaderContentType, contentType) - h.Set(echo.HeaderCacheControl, cacheMaxAge) + if h.Get(echo.HeaderCacheControl) == "" { + h.Set(echo.HeaderCacheControl, cacheMaxAge) + } // Support HDR/wide color gamut for images and videos. if strings.HasPrefix(originalType, "image/") || strings.HasPrefix(originalType, "video/") { diff --git a/server/router/fileserver/fileserver_test.go b/server/router/fileserver/fileserver_test.go index 6826f4d9..a63cd45a 100644 --- a/server/router/fileserver/fileserver_test.go +++ b/server/router/fileserver/fileserver_test.go @@ -18,6 +18,7 @@ import ( "github.com/labstack/echo/v5" "github.com/stretchr/testify/require" + "google.golang.org/protobuf/types/known/fieldmaskpb" "google.golang.org/protobuf/types/known/timestamppb" "github.com/usememos/memos/internal/markdown" @@ -84,6 +85,97 @@ func TestServeAttachmentFile_ShareTokenAllowsDirectMemoAttachment(t *testing.T) require.Equal(t, "memo attachment", rec.Body.String()) } +func TestServeAttachmentFile_CanonicalRouteAndVisibilityAwareCache(t *testing.T) { + ctx := context.Background() + svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t) + defer cleanup() + + creator, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "canonical-route-owner", + Role: store.RoleUser, + Email: "canonical-route-owner@example.com", + }) + require.NoError(t, err) + creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID) + attachment, err := svc.CreateAttachment(creatorCtx, &apiv1.CreateAttachmentRequest{Attachment: &apiv1.Attachment{ + Filename: "canonical.png", + Type: "image/png", + Content: []byte("canonical image"), + }}) + require.NoError(t, err) + memo, err := svc.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "canonical route", + Visibility: apiv1.Visibility_PUBLIC, + Attachments: []*apiv1.Attachment{{Name: attachment.Name}}, + }}) + require.NoError(t, err) + + e := echo.New() + fs.RegisterRoutes(e) + url := "/file/" + attachment.Name + rec := httptest.NewRecorder() + e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil)) + require.Equal(t, http.StatusOK, rec.Code) + require.Equal(t, "canonical image", rec.Body.String()) + require.Equal(t, publicAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl)) + + _, err = svc.UpdateMemo(creatorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: memo.Name, Visibility: apiv1.Visibility_PROTECTED}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}}, + }) + require.NoError(t, err) + rec = httptest.NewRecorder() + e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil)) + require.Equal(t, http.StatusUnauthorized, rec.Code) + require.Equal(t, privateAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl)) +} + +func TestServeAttachmentFile_CommentFollowsCurrentParentVisibility(t *testing.T) { + ctx := context.Background() + svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t) + defer cleanup() + + owner, err := svc.Store.CreateUser(ctx, &store.User{Username: "comment-parent-owner", Role: store.RoleUser, Email: "parent@example.com"}) + require.NoError(t, err) + commenter, err := svc.Store.CreateUser(ctx, &store.User{Username: "comment-file-owner", Role: store.RoleUser, Email: "commenter@example.com"}) + require.NoError(t, err) + ownerCtx := context.WithValue(ctx, auth.UserIDContextKey, owner.ID) + commenterCtx := context.WithValue(ctx, auth.UserIDContextKey, commenter.ID) + parent, err := svc.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{Content: "parent", Visibility: apiv1.Visibility_PUBLIC}}) + require.NoError(t, err) + attachment, err := svc.CreateAttachment(commenterCtx, &apiv1.CreateAttachmentRequest{Attachment: &apiv1.Attachment{ + Filename: "comment.png", + Type: "image/png", + Content: []byte("comment image"), + }}) + require.NoError(t, err) + _, err = svc.CreateMemoComment(commenterCtx, &apiv1.CreateMemoCommentRequest{ + Name: parent.Name, + Comment: &apiv1.Memo{ + Content: "comment", + Attachments: []*apiv1.Attachment{{Name: attachment.Name}}, + }, + }) + require.NoError(t, err) + + e := echo.New() + fs.RegisterRoutes(e) + url := "/file/" + attachment.Name + rec := httptest.NewRecorder() + e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil)) + require.Equal(t, http.StatusOK, rec.Code) + + _, err = svc.UpdateMemo(ownerCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: parent.Name, Visibility: apiv1.Visibility_PRIVATE}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}}, + }) + require.NoError(t, err) + rec = httptest.NewRecorder() + e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil)) + require.Equal(t, http.StatusUnauthorized, rec.Code) + require.Equal(t, privateAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl)) +} + func TestServeAttachmentFile_LocalStaticFileSupportsRangeRequests(t *testing.T) { ctx := context.Background() svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t) diff --git a/server/router/rss/rss.go b/server/router/rss/rss.go index a1ca2eb0..bafe5d1a 100644 --- a/server/router/rss/rss.go +++ b/server/router/rss/rss.go @@ -287,10 +287,10 @@ func (s *RSSService) generateRSSFromMemoList(ctx context.Context, memoList []*st if attachments, ok := attachmentsByMemoID[memo.ID]; ok && len(attachments) > 0 { attachment := attachments[0] enclosure := feeds.Enclosure{} - if attachment.StorageType == storepb.AttachmentStorageType_EXTERNAL || attachment.StorageType == storepb.AttachmentStorageType_S3 { + if attachment.StorageType == storepb.AttachmentStorageType_EXTERNAL { enclosure.Url = attachment.Reference } else { - enclosure.Url = fmt.Sprintf("%s/file/attachments/%s/%s", baseURL, attachment.UID, attachment.Filename) + enclosure.Url = fmt.Sprintf("%s/file/attachments/%s", baseURL, attachment.UID) } enclosure.Length = strconv.Itoa(int(attachment.Size)) enclosure.Type = attachment.Type diff --git a/store/attachment.go b/store/attachment.go index 69869a0b..8ac03af8 100644 --- a/store/attachment.go +++ b/store/attachment.go @@ -41,19 +41,20 @@ type Attachment struct { } type FindAttachment struct { - GetBlob bool - ID *int32 - UID *string - CreatorID *int32 - Filename *string - FilenameSearch *string - MemoID *int32 - MemoIDList []int32 - HasRelatedMemo bool - StorageType *storepb.AttachmentStorageType - Filters []string - Limit *int - Offset *int + GetBlob bool + ID *int32 + UID *string + CreatorID *int32 + Filename *string + FilenameSearch *string + MemoID *int32 + MemoIDList []int32 + HasRelatedMemo bool + StorageType *storepb.AttachmentStorageType + Filters []string + Limit *int + Offset *int + SkipDefaultLimit bool } type UpdateAttachment struct { @@ -95,7 +96,7 @@ func (s *Store) CreateAttachment(ctx context.Context, create *Attachment) (*Atta func (s *Store) ListAttachments(ctx context.Context, find *FindAttachment) ([]*Attachment, error) { // Set default limits to prevent loading too many attachments at once - shouldApplyDefaultLimit := find.Limit == nil && len(find.MemoIDList) == 0 + shouldApplyDefaultLimit := find.Limit == nil && find.MemoID == nil && len(find.MemoIDList) == 0 && !find.SkipDefaultLimit if shouldApplyDefaultLimit && find.GetBlob { // When fetching blobs, we should be especially careful with limits defaultLimit := 10 diff --git a/store/db/mysql/memo.go b/store/db/mysql/memo.go index 1f5f1b61..ef085b1e 100644 --- a/store/db/mysql/memo.go +++ b/store/db/mysql/memo.go @@ -215,45 +215,7 @@ func (d *DB) GetMemo(ctx context.Context, find *store.FindMemo) (*store.Memo, er } func (d *DB) UpdateMemo(ctx context.Context, update *store.UpdateMemo) error { - set, args := []string{}, []any{} - if v := update.UID; v != nil { - set, args = append(set, "`uid` = ?"), append(args, *v) - } - if v := update.CreatedTs; v != nil { - set, args = append(set, "`created_ts` = FROM_UNIXTIME(?)"), append(args, *v) - } - if v := update.UpdatedTs; v != nil { - set, args = append(set, "`updated_ts` = FROM_UNIXTIME(?)"), append(args, *v) - } - if v := update.RowStatus; v != nil { - set, args = append(set, "`row_status` = ?"), append(args, *v) - } - if v := update.Content; v != nil { - set, args = append(set, "`content` = ?"), append(args, *v) - } - if v := update.Visibility; v != nil { - set, args = append(set, "`visibility` = ?"), append(args, *v) - } - if v := update.Pinned; v != nil { - set, args = append(set, "`pinned` = ?"), append(args, *v) - } - if v := update.Payload; v != nil { - payloadBytes, err := protojson.Marshal(v) - if err != nil { - return err - } - set, args = append(set, "`payload` = ?"), append(args, string(payloadBytes)) - } - if len(set) == 0 { - return nil - } - args = append(args, update.ID) - - stmt := "UPDATE `memo` SET " + strings.Join(set, ", ") + " WHERE `id` = ?" - if _, err := d.db.ExecContext(ctx, stmt, args...); err != nil { - return err - } - return nil + return applyMemoUpdate(ctx, d.db, update) } func (d *DB) DeleteMemo(ctx context.Context, delete *store.DeleteMemo) error { diff --git a/store/db/mysql/memo_attachment.go b/store/db/mysql/memo_attachment.go new file mode 100644 index 00000000..130112f6 --- /dev/null +++ b/store/db/mysql/memo_attachment.go @@ -0,0 +1,156 @@ +package mysql + +import ( + "context" + "database/sql" + "strings" + + "github.com/pkg/errors" + "google.golang.org/protobuf/encoding/protojson" + + "github.com/usememos/memos/store" +) + +// ApplyMemoMutation atomically updates a memo, attachment bindings, and reference relations. +func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation) error { + tx, err := d.db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable}) + if err != nil { + return errors.Wrap(err, "failed to begin memo transaction") + } + defer func() { + _ = tx.Rollback() + }() + + var creatorID int32 + var content string + if err := tx.QueryRowContext(ctx, "SELECT `creator_id`, `content` FROM `memo` WHERE `id` = ? FOR UPDATE", mutation.MemoID).Scan(&creatorID, &content); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrap(store.ErrMemoMutationConflict, "memo no longer exists") + } + return errors.Wrap(err, "failed to lock memo") + } + if creatorID != mutation.MemoCreatorID || content != mutation.ExpectedMemoContent { + return errors.Wrap(store.ErrMemoMutationConflict, "memo changed while applying mutation") + } + + for _, binding := range mutation.Bindings { + var attachmentCreatorID int32 + var memoID sql.NullInt32 + if err := tx.QueryRowContext(ctx, "SELECT `creator_id`, `memo_id` FROM `attachment` WHERE `id` = ? FOR UPDATE", binding.ID).Scan(&attachmentCreatorID, &memoID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s no longer exists", binding.UID) + } + return errors.Wrap(err, "failed to lock attachment") + } + if binding.WasBoundToMemo { + if !memoID.Valid || memoID.Int32 != mutation.MemoID { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s is no longer bound to the memo", binding.UID) + } + } else if attachmentCreatorID != mutation.MemoCreatorID || memoID.Valid { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s is no longer available", binding.UID) + } + if _, err := tx.ExecContext(ctx, "UPDATE `attachment` SET `memo_id` = ?, `updated_ts` = FROM_UNIXTIME(?) WHERE `id` = ?", mutation.MemoID, binding.UpdatedTs, binding.ID); err != nil { + return errors.Wrap(err, "failed to bind attachment") + } + } + + for _, attachmentID := range mutation.RemovedAttachmentIDs { + result, err := tx.ExecContext(ctx, "UPDATE `attachment` SET `memo_id` = NULL WHERE `id` = ? AND `memo_id` = ?", attachmentID, mutation.MemoID) + if err != nil { + return errors.Wrap(err, "failed to detach attachment") + } + if rows, err := result.RowsAffected(); err != nil || rows != 1 { + return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer bound to the memo") + } + } + + for _, attachmentID := range mutation.RequiredAttachmentIDs { + var exists int + if err := tx.QueryRowContext(ctx, "SELECT 1 FROM `attachment` WHERE `id` = ? AND `memo_id` = ? FOR UPDATE", attachmentID, mutation.MemoID).Scan(&exists); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrap(store.ErrMemoMutationConflict, "a referenced attachment is no longer bound to the memo") + } + return errors.Wrap(err, "failed to verify referenced attachment") + } + } + + if mutation.MemoUpdate != nil { + if mutation.MemoUpdate.ID != mutation.MemoID { + return errors.New("memo update target does not match attachment mutation") + } + if err := applyMemoUpdate(ctx, tx, mutation.MemoUpdate); err != nil { + return err + } + } + if mutation.ReplaceReferenceRelations { + if err := replaceMemoReferenceRelations(ctx, tx, mutation.MemoID, mutation.ReferenceRelations); err != nil { + return err + } + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit memo transaction") + } + return nil +} + +func replaceMemoReferenceRelations(ctx context.Context, tx *sql.Tx, memoID int32, relations []*store.MemoRelation) error { + if _, err := tx.ExecContext(ctx, "DELETE FROM `memo_relation` WHERE `memo_id` = ? AND `type` = ?", memoID, store.MemoRelationReference); err != nil { + return errors.Wrap(err, "failed to delete memo reference relations") + } + for _, relation := range relations { + if relation == nil || relation.MemoID != memoID || relation.Type != store.MemoRelationReference { + return errors.New("invalid memo reference relation mutation") + } + if _, err := tx.ExecContext(ctx, + "INSERT INTO `memo_relation` (`memo_id`, `related_memo_id`, `type`) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE `type` = `type`", + relation.MemoID, relation.RelatedMemoID, relation.Type, + ); err != nil { + return errors.Wrap(err, "failed to insert memo reference relation") + } + } + return nil +} + +type memoUpdateExecer interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) +} + +func applyMemoUpdate(ctx context.Context, executor memoUpdateExecer, update *store.UpdateMemo) error { + set, args := []string{}, []any{} + if v := update.UID; v != nil { + set, args = append(set, "`uid` = ?"), append(args, *v) + } + if v := update.CreatedTs; v != nil { + set, args = append(set, "`created_ts` = FROM_UNIXTIME(?)"), append(args, *v) + } + if v := update.UpdatedTs; v != nil { + set, args = append(set, "`updated_ts` = FROM_UNIXTIME(?)"), append(args, *v) + } + if v := update.RowStatus; v != nil { + set, args = append(set, "`row_status` = ?"), append(args, *v) + } + if v := update.Content; v != nil { + set, args = append(set, "`content` = ?"), append(args, *v) + } + if v := update.Visibility; v != nil { + set, args = append(set, "`visibility` = ?"), append(args, *v) + } + if v := update.Pinned; v != nil { + set, args = append(set, "`pinned` = ?"), append(args, *v) + } + if v := update.Payload; v != nil { + payload, err := protojson.Marshal(v) + if err != nil { + return errors.Wrap(err, "failed to marshal memo payload") + } + set, args = append(set, "`payload` = ?"), append(args, string(payload)) + } + if len(set) == 0 { + return nil + } + args = append(args, update.ID) + if _, err := executor.ExecContext(ctx, "UPDATE `memo` SET "+strings.Join(set, ", ")+" WHERE `id` = ?", args...); err != nil { + return errors.Wrap(err, "failed to update memo") + } + return nil +} diff --git a/store/db/mysql/memo_relation.go b/store/db/mysql/memo_relation.go index 57a9ad49..400422b4 100644 --- a/store/db/mysql/memo_relation.go +++ b/store/db/mysql/memo_relation.go @@ -70,6 +70,10 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelation } where = append(where, fmt.Sprintf("`related_memo_id` IN (%s)", strings.Join(placeholders, ", "))) } + if find.SourceMemoRowStatus != nil { + where = append(where, "`memo_id` IN (SELECT `id` FROM `memo` WHERE `row_status` = ?)") + args = append(args, *find.SourceMemoRowStatus) + } if find.MemoFilter != nil { engine, err := filter.DefaultEngine() if err != nil { diff --git a/store/db/postgres/memo.go b/store/db/postgres/memo.go index 973b637c..8b69db85 100644 --- a/store/db/postgres/memo.go +++ b/store/db/postgres/memo.go @@ -200,45 +200,7 @@ func (d *DB) GetMemo(ctx context.Context, find *store.FindMemo) (*store.Memo, er } func (d *DB) UpdateMemo(ctx context.Context, update *store.UpdateMemo) error { - set, args := []string{}, []any{} - if v := update.UID; v != nil { - set, args = append(set, "uid = "+placeholder(len(args)+1)), append(args, *v) - } - if v := update.CreatedTs; v != nil { - set, args = append(set, "created_ts = "+placeholder(len(args)+1)), append(args, *v) - } - if v := update.UpdatedTs; v != nil { - set, args = append(set, "updated_ts = "+placeholder(len(args)+1)), append(args, *v) - } - if v := update.RowStatus; v != nil { - set, args = append(set, "row_status = "+placeholder(len(args)+1)), append(args, *v) - } - if v := update.Content; v != nil { - set, args = append(set, "content = "+placeholder(len(args)+1)), append(args, *v) - } - if v := update.Visibility; v != nil { - set, args = append(set, "visibility = "+placeholder(len(args)+1)), append(args, *v) - } - if v := update.Pinned; v != nil { - set, args = append(set, "pinned = "+placeholder(len(args)+1)), append(args, *v) - } - if v := update.Payload; v != nil { - payloadBytes, err := protojson.Marshal(v) - if err != nil { - return err - } - set, args = append(set, "payload = "+placeholder(len(args)+1)), append(args, string(payloadBytes)) - } - if len(set) == 0 { - return nil - } - - stmt := `UPDATE memo SET ` + strings.Join(set, ", ") + ` WHERE id = ` + placeholder(len(args)+1) - args = append(args, update.ID) - if _, err := d.db.ExecContext(ctx, stmt, args...); err != nil { - return err - } - return nil + return applyMemoUpdate(ctx, d.db, update) } func (d *DB) DeleteMemo(ctx context.Context, delete *store.DeleteMemo) error { diff --git a/store/db/postgres/memo_attachment.go b/store/db/postgres/memo_attachment.go new file mode 100644 index 00000000..7b3b195f --- /dev/null +++ b/store/db/postgres/memo_attachment.go @@ -0,0 +1,161 @@ +package postgres + +import ( + "context" + "database/sql" + "strings" + + "github.com/pkg/errors" + "google.golang.org/protobuf/encoding/protojson" + + "github.com/usememos/memos/store" +) + +// ApplyMemoMutation atomically updates a memo, attachment bindings, and reference relations. +func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation) error { + tx, err := d.db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable}) + if err != nil { + return errors.Wrap(err, "failed to begin memo transaction") + } + defer func() { + _ = tx.Rollback() + }() + + var creatorID int32 + var content string + if err := tx.QueryRowContext(ctx, `SELECT creator_id, content FROM memo WHERE id = $1 FOR UPDATE`, mutation.MemoID).Scan(&creatorID, &content); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrap(store.ErrMemoMutationConflict, "memo no longer exists") + } + return errors.Wrap(err, "failed to lock memo") + } + if creatorID != mutation.MemoCreatorID || content != mutation.ExpectedMemoContent { + return errors.Wrap(store.ErrMemoMutationConflict, "memo changed while applying mutation") + } + + for _, binding := range mutation.Bindings { + var attachmentCreatorID int32 + var memoID sql.NullInt32 + if err := tx.QueryRowContext(ctx, `SELECT creator_id, memo_id FROM attachment WHERE id = $1 FOR UPDATE`, binding.ID).Scan(&attachmentCreatorID, &memoID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s no longer exists", binding.UID) + } + return errors.Wrap(err, "failed to lock attachment") + } + if binding.WasBoundToMemo { + if !memoID.Valid || memoID.Int32 != mutation.MemoID { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s is no longer bound to the memo", binding.UID) + } + } else if attachmentCreatorID != mutation.MemoCreatorID || memoID.Valid { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s is no longer available", binding.UID) + } + if _, err := tx.ExecContext(ctx, `UPDATE attachment SET memo_id = $1, updated_ts = $2 WHERE id = $3`, mutation.MemoID, binding.UpdatedTs, binding.ID); err != nil { + return errors.Wrap(err, "failed to bind attachment") + } + } + + for _, attachmentID := range mutation.RemovedAttachmentIDs { + result, err := tx.ExecContext(ctx, `UPDATE attachment SET memo_id = NULL WHERE id = $1 AND memo_id = $2`, attachmentID, mutation.MemoID) + if err != nil { + return errors.Wrap(err, "failed to detach attachment") + } + if rows, err := result.RowsAffected(); err != nil || rows != 1 { + return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer bound to the memo") + } + } + + for _, attachmentID := range mutation.RequiredAttachmentIDs { + var exists int + if err := tx.QueryRowContext(ctx, `SELECT 1 FROM attachment WHERE id = $1 AND memo_id = $2 FOR UPDATE`, attachmentID, mutation.MemoID).Scan(&exists); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrap(store.ErrMemoMutationConflict, "a referenced attachment is no longer bound to the memo") + } + return errors.Wrap(err, "failed to verify referenced attachment") + } + } + + if mutation.MemoUpdate != nil { + if mutation.MemoUpdate.ID != mutation.MemoID { + return errors.New("memo update target does not match attachment mutation") + } + if err := applyMemoUpdate(ctx, tx, mutation.MemoUpdate); err != nil { + return err + } + } + if mutation.ReplaceReferenceRelations { + if err := replaceMemoReferenceRelations(ctx, tx, mutation.MemoID, mutation.ReferenceRelations); err != nil { + return err + } + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit memo transaction") + } + return nil +} + +func replaceMemoReferenceRelations(ctx context.Context, tx *sql.Tx, memoID int32, relations []*store.MemoRelation) error { + if _, err := tx.ExecContext(ctx, `DELETE FROM memo_relation WHERE memo_id = $1 AND type = $2`, memoID, store.MemoRelationReference); err != nil { + return errors.Wrap(err, "failed to delete memo reference relations") + } + for _, relation := range relations { + if relation == nil || relation.MemoID != memoID || relation.Type != store.MemoRelationReference { + return errors.New("invalid memo reference relation mutation") + } + if _, err := tx.ExecContext(ctx, ` + INSERT INTO memo_relation (memo_id, related_memo_id, type) + VALUES ($1, $2, $3) + ON CONFLICT (memo_id, related_memo_id, type) DO UPDATE SET type = EXCLUDED.type + `, relation.MemoID, relation.RelatedMemoID, relation.Type); err != nil { + return errors.Wrap(err, "failed to insert memo reference relation") + } + } + return nil +} + +type memoUpdateExecer interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) +} + +func applyMemoUpdate(ctx context.Context, executor memoUpdateExecer, update *store.UpdateMemo) error { + set, args := []string{}, []any{} + appendValue := func(column string, value any) { + args = append(args, value) + set = append(set, column+" = "+placeholder(len(args))) + } + if v := update.UID; v != nil { + appendValue("uid", *v) + } + if v := update.CreatedTs; v != nil { + appendValue("created_ts", *v) + } + if v := update.UpdatedTs; v != nil { + appendValue("updated_ts", *v) + } + if v := update.RowStatus; v != nil { + appendValue("row_status", *v) + } + if v := update.Content; v != nil { + appendValue("content", *v) + } + if v := update.Visibility; v != nil { + appendValue("visibility", *v) + } + if v := update.Pinned; v != nil { + appendValue("pinned", *v) + } + if v := update.Payload; v != nil { + payload, err := protojson.Marshal(v) + if err != nil { + return errors.Wrap(err, "failed to marshal memo payload") + } + appendValue("payload", string(payload)) + } + if len(set) == 0 { + return nil + } + args = append(args, update.ID) + if _, err := executor.ExecContext(ctx, "UPDATE memo SET "+strings.Join(set, ", ")+" WHERE id = "+placeholder(len(args)), args...); err != nil { + return errors.Wrap(err, "failed to update memo") + } + return nil +} diff --git a/store/db/postgres/memo_relation.go b/store/db/postgres/memo_relation.go index 316b95aa..68bd2216 100644 --- a/store/db/postgres/memo_relation.go +++ b/store/db/postgres/memo_relation.go @@ -79,6 +79,10 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelation } where = append(where, fmt.Sprintf("related_memo_id IN (%s)", strings.Join(placeholders, ", "))) } + if find.SourceMemoRowStatus != nil { + where = append(where, "memo_id IN (SELECT id FROM memo WHERE row_status = "+placeholder(len(args)+1)+")") + args = append(args, *find.SourceMemoRowStatus) + } if find.MemoFilter != nil { engine, err := filter.DefaultEngine() if err != nil { diff --git a/store/db/sqlite/memo.go b/store/db/sqlite/memo.go index 1d1ac686..4d2b13fe 100644 --- a/store/db/sqlite/memo.go +++ b/store/db/sqlite/memo.go @@ -193,45 +193,7 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo } func (d *DB) UpdateMemo(ctx context.Context, update *store.UpdateMemo) error { - set, args := []string{}, []any{} - if v := update.UID; v != nil { - set, args = append(set, "`uid` = ?"), append(args, *v) - } - if v := update.CreatedTs; v != nil { - set, args = append(set, "`created_ts` = ?"), append(args, *v) - } - if v := update.UpdatedTs; v != nil { - set, args = append(set, "`updated_ts` = ?"), append(args, *v) - } - if v := update.RowStatus; v != nil { - set, args = append(set, "`row_status` = ?"), append(args, *v) - } - if v := update.Content; v != nil { - set, args = append(set, "`content` = ?"), append(args, *v) - } - if v := update.Visibility; v != nil { - set, args = append(set, "`visibility` = ?"), append(args, *v) - } - if v := update.Pinned; v != nil { - set, args = append(set, "`pinned` = ?"), append(args, *v) - } - if v := update.Payload; v != nil { - payloadBytes, err := protojson.Marshal(v) - if err != nil { - return err - } - set, args = append(set, "`payload` = ?"), append(args, string(payloadBytes)) - } - if len(set) == 0 { - return nil - } - args = append(args, update.ID) - - stmt := "UPDATE `memo` SET " + strings.Join(set, ", ") + " WHERE `id` = ?" - if _, err := d.db.ExecContext(ctx, stmt, args...); err != nil { - return err - } - return nil + return applyMemoUpdate(ctx, d.db, update) } func (d *DB) DeleteMemo(ctx context.Context, delete *store.DeleteMemo) error { diff --git a/store/db/sqlite/memo_attachment.go b/store/db/sqlite/memo_attachment.go new file mode 100644 index 00000000..12b07f02 --- /dev/null +++ b/store/db/sqlite/memo_attachment.go @@ -0,0 +1,157 @@ +package sqlite + +import ( + "context" + "database/sql" + "strings" + + "github.com/pkg/errors" + "google.golang.org/protobuf/encoding/protojson" + + "github.com/usememos/memos/store" +) + +// ApplyMemoMutation atomically updates a memo, attachment bindings, and reference relations. +func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation) error { + tx, err := d.db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable}) + if err != nil { + return errors.Wrap(err, "failed to begin memo transaction") + } + defer func() { + _ = tx.Rollback() + }() + + var creatorID int32 + var content string + if err := tx.QueryRowContext(ctx, `SELECT creator_id, content FROM memo WHERE id = ?`, mutation.MemoID).Scan(&creatorID, &content); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrap(store.ErrMemoMutationConflict, "memo no longer exists") + } + return errors.Wrap(err, "failed to lock memo") + } + if creatorID != mutation.MemoCreatorID || content != mutation.ExpectedMemoContent { + return errors.Wrap(store.ErrMemoMutationConflict, "memo changed while applying mutation") + } + + for _, binding := range mutation.Bindings { + var attachmentCreatorID int32 + var memoID sql.NullInt32 + if err := tx.QueryRowContext(ctx, `SELECT creator_id, memo_id FROM attachment WHERE id = ?`, binding.ID).Scan(&attachmentCreatorID, &memoID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s no longer exists", binding.UID) + } + return errors.Wrap(err, "failed to lock attachment") + } + if binding.WasBoundToMemo { + if !memoID.Valid || memoID.Int32 != mutation.MemoID { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s is no longer bound to the memo", binding.UID) + } + } else if attachmentCreatorID != mutation.MemoCreatorID || memoID.Valid { + return errors.Wrapf(store.ErrMemoMutationConflict, "attachment %s is no longer available", binding.UID) + } + if _, err := tx.ExecContext(ctx, `UPDATE attachment SET memo_id = ?, updated_ts = ? WHERE id = ?`, mutation.MemoID, binding.UpdatedTs, binding.ID); err != nil { + return errors.Wrap(err, "failed to bind attachment") + } + } + + for _, attachmentID := range mutation.RemovedAttachmentIDs { + result, err := tx.ExecContext(ctx, `UPDATE attachment SET memo_id = NULL WHERE id = ? AND memo_id = ?`, attachmentID, mutation.MemoID) + if err != nil { + return errors.Wrap(err, "failed to detach attachment") + } + if rows, err := result.RowsAffected(); err != nil || rows != 1 { + return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer bound to the memo") + } + } + + for _, attachmentID := range mutation.RequiredAttachmentIDs { + var exists int + if err := tx.QueryRowContext(ctx, `SELECT 1 FROM attachment WHERE id = ? AND memo_id = ?`, attachmentID, mutation.MemoID).Scan(&exists); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return errors.Wrap(store.ErrMemoMutationConflict, "a referenced attachment is no longer bound to the memo") + } + return errors.Wrap(err, "failed to verify referenced attachment") + } + } + + if mutation.MemoUpdate != nil { + if mutation.MemoUpdate.ID != mutation.MemoID { + return errors.New("memo update target does not match attachment mutation") + } + if err := applyMemoUpdate(ctx, tx, mutation.MemoUpdate); err != nil { + return err + } + } + if mutation.ReplaceReferenceRelations { + if err := replaceMemoReferenceRelations(ctx, tx, mutation.MemoID, mutation.ReferenceRelations); err != nil { + return err + } + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit memo transaction") + } + return nil +} + +func replaceMemoReferenceRelations(ctx context.Context, tx *sql.Tx, memoID int32, relations []*store.MemoRelation) error { + if _, err := tx.ExecContext(ctx, `DELETE FROM memo_relation WHERE memo_id = ? AND type = ?`, memoID, store.MemoRelationReference); err != nil { + return errors.Wrap(err, "failed to delete memo reference relations") + } + for _, relation := range relations { + if relation == nil || relation.MemoID != memoID || relation.Type != store.MemoRelationReference { + return errors.New("invalid memo reference relation mutation") + } + if _, err := tx.ExecContext(ctx, ` + INSERT INTO memo_relation (memo_id, related_memo_id, type) + VALUES (?, ?, ?) + ON CONFLICT(memo_id, related_memo_id, type) DO UPDATE SET type = excluded.type + `, relation.MemoID, relation.RelatedMemoID, relation.Type); err != nil { + return errors.Wrap(err, "failed to insert memo reference relation") + } + } + return nil +} + +type memoUpdateExecer interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) +} + +func applyMemoUpdate(ctx context.Context, executor memoUpdateExecer, update *store.UpdateMemo) error { + set, args := []string{}, []any{} + if v := update.UID; v != nil { + set, args = append(set, "`uid` = ?"), append(args, *v) + } + if v := update.CreatedTs; v != nil { + set, args = append(set, "`created_ts` = ?"), append(args, *v) + } + if v := update.UpdatedTs; v != nil { + set, args = append(set, "`updated_ts` = ?"), append(args, *v) + } + if v := update.RowStatus; v != nil { + set, args = append(set, "`row_status` = ?"), append(args, *v) + } + if v := update.Content; v != nil { + set, args = append(set, "`content` = ?"), append(args, *v) + } + if v := update.Visibility; v != nil { + set, args = append(set, "`visibility` = ?"), append(args, *v) + } + if v := update.Pinned; v != nil { + set, args = append(set, "`pinned` = ?"), append(args, *v) + } + if v := update.Payload; v != nil { + payload, err := protojson.Marshal(v) + if err != nil { + return errors.Wrap(err, "failed to marshal memo payload") + } + set, args = append(set, "`payload` = ?"), append(args, string(payload)) + } + if len(set) == 0 { + return nil + } + args = append(args, update.ID) + if _, err := executor.ExecContext(ctx, "UPDATE `memo` SET "+strings.Join(set, ", ")+" WHERE `id` = ?", args...); err != nil { + return errors.Wrap(err, "failed to update memo") + } + return nil +} diff --git a/store/db/sqlite/memo_relation.go b/store/db/sqlite/memo_relation.go index 9a691c12..16631986 100644 --- a/store/db/sqlite/memo_relation.go +++ b/store/db/sqlite/memo_relation.go @@ -77,6 +77,10 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelation } where = append(where, fmt.Sprintf("related_memo_id IN (%s)", strings.Join(placeholders, ", "))) } + if find.SourceMemoRowStatus != nil { + where = append(where, "memo_id IN (SELECT id FROM memo WHERE row_status = ?)") + args = append(args, *find.SourceMemoRowStatus) + } if find.MemoFilter != nil { engine, err := filter.DefaultEngine() if err != nil { diff --git a/store/driver.go b/store/driver.go index 5a265bdd..000b68dc 100644 --- a/store/driver.go +++ b/store/driver.go @@ -24,6 +24,7 @@ type Driver interface { UpdateAttachment(ctx context.Context, update *UpdateAttachment) error DeleteAttachment(ctx context.Context, delete *DeleteAttachment) error DeleteAttachments(ctx context.Context, deletes []*DeleteAttachment) error + ApplyMemoMutation(ctx context.Context, mutation *MemoMutation) error // Memo model related methods. CreateMemo(ctx context.Context, create *Memo) (*Memo, error) diff --git a/store/memo_attachment.go b/store/memo_attachment.go new file mode 100644 index 00000000..3f9c985b --- /dev/null +++ b/store/memo_attachment.go @@ -0,0 +1,46 @@ +package store + +import ( + "context" + "errors" +) + +// ErrMemoMutationConflict indicates that memo or attachment state changed +// after an API request prepared its mutation. +var ErrMemoMutationConflict = errors.New("memo state changed") + +// MemoAttachmentBinding describes one attachment that should be bound to a +// memo. WasBoundToMemo distinguishes an existing binding from a new one so the +// driver can reject ownership transfers while preserving legacy rows already +// attached to the memo. +type MemoAttachmentBinding struct { + ID int32 + UID string + UpdatedTs int64 + WasBoundToMemo bool +} + +// MemoMutation atomically updates a memo, its attachment bindings, and its +// reference relations. Removed attachment rows are detached in the transaction +// and are deleted from storage separately, so a storage failure remains +// retriable. +type MemoMutation struct { + MemoID int32 + MemoCreatorID int32 + ExpectedMemoContent string + MemoUpdate *UpdateMemo + Bindings []*MemoAttachmentBinding + RemovedAttachmentIDs []int32 + RequiredAttachmentIDs []int32 + ReplaceReferenceRelations bool + ReferenceRelations []*MemoRelation +} + +// ApplyMemoMutation atomically applies memo fields, attachment bindings, and +// reference relations after rechecking the state used by API validation. +func (s *Store) ApplyMemoMutation(ctx context.Context, mutation *MemoMutation) error { + if mutation == nil { + return errors.New("memo mutation is required") + } + return s.driver.ApplyMemoMutation(ctx, mutation) +} diff --git a/store/memo_relation.go b/store/memo_relation.go index 12a44866..c6645a64 100644 --- a/store/memo_relation.go +++ b/store/memo_relation.go @@ -24,6 +24,8 @@ type FindMemoRelation struct { RelatedMemoID *int32 Type *MemoRelationType MemoFilter *string + // SourceMemoRowStatus filters the relation source memo before pagination. + SourceMemoRowStatus *RowStatus // MemoIDList matches relations where memo_id OR related_memo_id is in the list. MemoIDList []int32 // SourceMemoIDList matches relations where memo_id is in the list. diff --git a/store/test/attachment_test.go b/store/test/attachment_test.go index 96fa3414..0b85c2c0 100644 --- a/store/test/attachment_test.go +++ b/store/test/attachment_test.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "testing" + "time" "github.com/lithammer/shortuuid/v4" "github.com/stretchr/testify/require" @@ -122,6 +123,198 @@ func TestAttachmentStore(t *testing.T) { ts.Close() } +func TestMemoMutationRollsBackOnBindingConflict(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: shortuuid.New(), + CreatorID: user.ID, + Content: "original", + Visibility: store.Private, + }) + require.NoError(t, err) + otherMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: shortuuid.New(), + CreatorID: user.ID, + Content: "other", + Visibility: store.Private, + }) + require.NoError(t, err) + available, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), + CreatorID: user.ID, + Filename: "available.png", + Type: "image/png", + }) + require.NoError(t, err) + conflicting, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), + CreatorID: user.ID, + Filename: "conflicting.png", + Type: "image/png", + MemoID: &otherMemo.ID, + }) + require.NoError(t, err) + + updatedContent := "updated" + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: memo.ID, + MemoCreatorID: user.ID, + ExpectedMemoContent: memo.Content, + MemoUpdate: &store.UpdateMemo{ID: memo.ID, Content: &updatedContent}, + Bindings: []*store.MemoAttachmentBinding{ + {ID: available.ID, UID: available.UID, UpdatedTs: time.Now().Unix()}, + {ID: conflicting.ID, UID: conflicting.UID, UpdatedTs: time.Now().Unix() + 1}, + }, + }) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) + + storedMemo, err := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, err) + require.Equal(t, "original", storedMemo.Content) + storedAvailable, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &available.ID}) + require.NoError(t, err) + require.Nil(t, storedAvailable.MemoID) + storedConflicting, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &conflicting.ID}) + require.NoError(t, err) + require.NotNil(t, storedConflicting.MemoID) + require.Equal(t, otherMemo.ID, *storedConflicting.MemoID) +} + +func TestMemoMutationUpdatesMemoAndBindingsTogether(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "old", Visibility: store.Private}) + require.NoError(t, err) + removed, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: "removed.png", Type: "image/png", MemoID: &memo.ID, + }) + require.NoError(t, err) + added, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: "added.png", Type: "image/png", + }) + require.NoError(t, err) + + updatedContent := "new" + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: memo.ID, + MemoCreatorID: user.ID, + ExpectedMemoContent: memo.Content, + MemoUpdate: &store.UpdateMemo{ID: memo.ID, Content: &updatedContent}, + Bindings: []*store.MemoAttachmentBinding{ + {ID: added.ID, UID: added.UID, UpdatedTs: time.Now().Unix()}, + }, + RemovedAttachmentIDs: []int32{removed.ID}, + RequiredAttachmentIDs: []int32{added.ID}, + }) + require.NoError(t, err) + + storedMemo, err := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, err) + require.Equal(t, "new", storedMemo.Content) + storedAdded, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &added.ID}) + require.NoError(t, err) + require.NotNil(t, storedAdded.MemoID) + require.Equal(t, memo.ID, *storedAdded.MemoID) + storedRemoved, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &removed.ID}) + require.NoError(t, err) + require.Nil(t, storedRemoved.MemoID) +} + +func TestMemoMutationRollsBackWhenRequiredAttachmentIsMissing(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "old", Visibility: store.Private}) + require.NoError(t, err) + removed, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: "kept.png", Type: "image/png", MemoID: &memo.ID, + }) + require.NoError(t, err) + added, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: "rolled-back.png", Type: "image/png", + }) + require.NoError(t, err) + + updatedContent := "new" + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: memo.ID, + MemoCreatorID: user.ID, + ExpectedMemoContent: memo.Content, + MemoUpdate: &store.UpdateMemo{ID: memo.ID, Content: &updatedContent}, + Bindings: []*store.MemoAttachmentBinding{ + {ID: added.ID, UID: added.UID, UpdatedTs: time.Now().Unix()}, + }, + RemovedAttachmentIDs: []int32{removed.ID}, + RequiredAttachmentIDs: []int32{added.ID + removed.ID + 1000}, + }) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) + + storedMemo, err := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, err) + require.Equal(t, "old", storedMemo.Content) + storedAdded, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &added.ID}) + require.NoError(t, err) + require.Nil(t, storedAdded.MemoID) + storedRemoved, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &removed.ID}) + require.NoError(t, err) + require.NotNil(t, storedRemoved.MemoID) + require.Equal(t, memo.ID, *storedRemoved.MemoID) +} + +func TestMemoMutationRollsBackMemoAndRelationsTogether(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + source, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "original", Visibility: store.Private}) + require.NoError(t, err) + originalTarget, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "original target", Visibility: store.Private}) + require.NoError(t, err) + replacementTarget, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "replacement target", Visibility: store.Private}) + require.NoError(t, err) + _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ + MemoID: source.ID, RelatedMemoID: originalTarget.ID, Type: store.MemoRelationReference, + }) + require.NoError(t, err) + + updatedContent := "must roll back" + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: source.ID, + MemoCreatorID: user.ID, + ExpectedMemoContent: source.Content, + MemoUpdate: &store.UpdateMemo{ID: source.ID, Content: &updatedContent}, + ReplaceReferenceRelations: true, + ReferenceRelations: []*store.MemoRelation{ + {MemoID: source.ID, RelatedMemoID: replacementTarget.ID, Type: store.MemoRelationReference}, + {MemoID: source.ID, RelatedMemoID: originalTarget.ID, Type: store.MemoRelationComment}, + }, + }) + require.Error(t, err) + + stored, err := ts.GetMemo(ctx, &store.FindMemo{ID: &source.ID}) + require.NoError(t, err) + require.Equal(t, "original", stored.Content) + referenceType := store.MemoRelationReference + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &source.ID, Type: &referenceType}) + require.NoError(t, err) + require.Len(t, relations, 1) + require.Equal(t, originalTarget.ID, relations[0].RelatedMemoID) +} + func TestAttachmentStoreWithFilter(t *testing.T) { t.Parallel() ctx := context.Background() diff --git a/store/test/memo_relation_test.go b/store/test/memo_relation_test.go index 5abaaa3f..2276e2a8 100644 --- a/store/test/memo_relation_test.go +++ b/store/test/memo_relation_test.go @@ -944,3 +944,37 @@ func TestMemoRelationMultipleRelationsToSameMemo(t *testing.T) { ts.Close() } + +func TestMemoRelationFiltersSourceStatusBeforePagination(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + parent, err := ts.CreateMemo(ctx, &store.Memo{UID: "status-parent", CreatorID: user.ID, Content: "parent", Visibility: store.Public}) + require.NoError(t, err) + normalMemo, err := ts.CreateMemo(ctx, &store.Memo{UID: "status-normal", CreatorID: user.ID, Content: "normal", Visibility: store.Public}) + require.NoError(t, err) + archivedMemo, err := ts.CreateMemo(ctx, &store.Memo{UID: "status-archived", CreatorID: user.ID, Content: "archived", Visibility: store.Public}) + require.NoError(t, err) + archived := store.Archived + require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: archivedMemo.ID, RowStatus: &archived})) + for _, memoID := range []int32{normalMemo.ID, archivedMemo.ID} { + _, err := ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: memoID, RelatedMemoID: parent.ID, Type: store.MemoRelationComment}) + require.NoError(t, err) + } + + normal := store.Normal + commentType := store.MemoRelationComment + limit := 1 + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{ + RelatedMemoID: &parent.ID, + Type: &commentType, + SourceMemoRowStatus: &normal, + Limit: &limit, + }) + require.NoError(t, err) + require.Len(t, relations, 1) + require.Equal(t, normalMemo.ID, relations[0].MemoID) +}