Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
feat: support memo-scoped Markdown attachment images (#6169)
Johnnybd636a436522
diff --git a/internal/markdown/markdown.go b/internal/markdown/markdown.goindex e43b3f959..e7291ce95 100644--- a/internal/markdown/markdown.go+++ b/internal/markdown/markdown.go@@ -3,6 +3,7 @@ package markdownimport ("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 casedata.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.goindex 6b742d5e2..1a26356c7 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{+ "",+ "",+ "",+ "![reference][managed-image]",+ "",+ "[managed-image]: /file/attachments/image-three",+ "",+ "``",+ }, "\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{+ "",+ "",+ "",+ `<img src="/file/attachments/raw-html">`,+ }, "\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 <img src="/file/attachments/inline-image"> after`,+ },+ {+ name: "HTML block",+ content: strings.Join([]string{+ "<div>",+ ` <img src="/file/attachments/block-image">`,+ "</div>",+ }, "\n"),+ },+ {+ name: "self-closing HTML block",+ content: strings.Join([]string{+ `<img`,+ ` src="/file/attachments/multiline-image"`,+ `/>`,+ }, "\n"),+ },+ {+ name: "HTML block closure line",+ content: strings.Join([]string{+ "<pre>",+ "content",+ `</pre><img src="/file/attachments/closure-image">`,+ }, "\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{+ "`<img src=\"/file/attachments/inline-code\">`",+ "",+ "```html",+ `<img src="/file/attachments/fenced-code">`,+ "```",+ }, "\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.gonew file mode 100644index 000000000..18ac182db--- /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.gonew file mode 100644index 000000000..73a19b52f--- /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.goindex a9233cbc1..449ea86bc 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.goindex 7da7011ec..f1c67bdce 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.goindex b8d2282cc..6602fe70c 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.Creatif !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.Deletif 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 *streturn 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.goindex ea355b6f7..a1738e9c3 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.gonew file mode 100644index 000000000..f73275abc--- /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.goindex 07344769f..9379bfab1 100644--- a/server/router/api/v1/memo_attachment_service.go+++ b/server/router/api/v1/memo_attachment_service.go@@ -2,14 +2,19 @@ package v1import ("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.Setif !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+ }+ requiredAttachmentIDs, err := s.resolveMemoAttachmentReferences(memo.Content, prepared.normalized)+ 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, 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.Setreturn &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 *storequestedIDs[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 != user.ID && !isSuperUser(user) {- return status.Errorf(codes.PermissionDenied, "cannot remove another user's attachment")+ if attachment.CreatorID != memo.CreatorID {+ return nil, status.Errorf(codes.FailedPrecondition, "cannot remove another user's attachment from this memo")}- 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")+ if attachment.CreatorID != user.ID && !isSuperUser(user) {+ 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 *stofunc (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.Lireturn 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.goindex 382d72143..7607f37da 100644--- a/server/router/api/v1/memo_relation_service.go+++ b/server/router/api/v1/memo_relation_service.go@@ -3,6 +3,7 @@ package v1import ("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.SetMeif 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.SetMereturn &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 relatedMemo == nil {+ return nil, status.Errorf(codes.NotFound, "related memo not found")}- if _, err := s.Store.UpsertMemoRelation(ctx, &store.MemoRelation{+ 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.goindex 5938b8065..1bd278838 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.CreateMemoRif 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.CreateMemoRcreate.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.GetMemoRequestreturn 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.UpdateMemoRupdate := &store.UpdateMemo{ID: memo.ID,}- var previousContent string+ previousContent := memo.ContentcontentUpdated := 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.ContentcontentLengthLimit, 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.UpdateMemoRif 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.UpdateMemoRrowStatus := 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- } 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")+ if nextMemo.Payload == nil {+ nextMemo.Payload = &storepb.MemoPayload{}}+ nextMemo.Payload.Location = convertLocationToStore(request.Memo.Location)+ update.Payload = nextMemo.Payload+ } else if path == "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+ }+ }++ 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 err = s.Store.UpdateMemo(ctx, update); err != nil {+ 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.goindex 8f62b43a6..1b435aaf4 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.Creaif 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.ListMreturn 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.MemoRelationCommentvar limit, offset intif request.PageToken != "" {@@ -172,12 +165,13 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListMlimit = normalizePageSize(request.PageSize)}limitPlusOne := limit + 1+ normal := store.NormalmemoRelations, 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.ListMfor _, 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.goindex 80181fe0f..69cdbb6a7 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.Createif 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.GetSharereturn 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.goindex 2c5f7e044..d619a9402 100644--- a/server/router/api/v1/memo_update_helpers.go+++ b/server/router/api/v1/memo_update_helpers.go@@ -3,27 +3,13 @@ package v1import ("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.Memoif 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, memoslog.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.goindex cab318684..7e32554b8 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 testimport ("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.gonew file mode 100644index 000000000..14ff9ac7b--- /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("\n", 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: "",+ 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("", 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("", 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("", 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: "",+ }})+ 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("", 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("", 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("", 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("", 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: ""},+ 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("", 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.goindex a715a81b3..752cc3493 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.goindex 98c2c5659..a0092b224 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.goindex d28988ed8..9e9c6ba48 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/5483func 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.goindex 12cb0ee07..af03a77eb 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.goindex 63c4dc1f1..ad71baae0 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")+ }+ }++ allowAnonymous := s.Profile != nil && s.Profile.AllowAnonymous()+ if decision := access.CheckMemoRead(memo, parent, nil, allowAnonymous, nil); decision.Allowed() {+ return decision.Class, nil}- // 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.+ var sharedMemoID *int32if 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)- }- if user == nil {- return echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access")- }-- if memo.Visibility == store.Private && user.ID != memo.CreatorID && user.Role != store.RoleAdmin {- return echo.NewHTTPError(http.StatusForbidden, "forbidden access")+ return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err)+ }+ 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")}-- 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.goindex 6826f4d93..a63cd45a1 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: "[email protected]",+ })+ 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: "[email protected]"})+ require.NoError(t, err)+ commenter, err := svc.Store.CreateUser(ctx, &store.User{Username: "comment-file-owner", Role: store.RoleUser, Email: "[email protected]"})+ 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.goindex a1ca2eb0c..bafe5d1a8 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 []*stif 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.Typediff --git a/store/attachment.go b/store/attachment.goindex 69869a0b9..8ac03af89 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) (*Attafunc (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.SkipDefaultLimitif shouldApplyDefaultLimit && find.GetBlob {// When fetching blobs, we should be especially careful with limitsdefaultLimit := 10diff --git a/store/db/mysql/memo.go b/store/db/mysql/memo.goindex 1f5f1b61c..ef085b1e0 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.gonew file mode 100644index 000000000..130112f65--- /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.goindex 57a9ad49d..400422b47 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.goindex 973b637c5..8b69db850 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.gonew file mode 100644index 000000000..7b3b195fb--- /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.goindex 316b95aa0..68bd22165 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.goindex 1d1ac6861..4d2b13fe5 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.gonew file mode 100644index 000000000..12b07f027--- /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.goindex 9a691c121..166319868 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.goindex 5a265bddf..000b68dc3 100644--- a/store/driver.go+++ b/store/driver.go@@ -24,6 +24,7 @@ type Driver interface {UpdateAttachment(ctx context.Context, update *UpdateAttachment) errorDeleteAttachment(ctx context.Context, delete *DeleteAttachment) errorDeleteAttachments(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.gonew file mode 100644index 000000000..3f9c985bd--- /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.goindex 12a448665..c6645a648 100644--- a/store/memo_relation.go+++ b/store/memo_relation.go@@ -24,6 +24,8 @@ type FindMemoRelation struct {RelatedMemoID *int32Type *MemoRelationTypeMemoFilter *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.goindex 96fa3414b..0b85c2c0c 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.goindex 5abaaa3f0..2276e2a8b 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)+}