package v1 import ( "context" "fmt" "time" "github.com/pkg/errors" "google.golang.org/protobuf/types/known/timestamppb" v1pb "github.com/usememos/memos/proto/gen/api/v1" storepb "github.com/usememos/memos/proto/gen/store" "github.com/usememos/memos/store" ) func (s *APIV1Service) convertMemoFromStore(ctx context.Context, memo *store.Memo, reactions []*store.Reaction, attachments []*store.Attachment, relations []*v1pb.MemoRelation) (*v1pb.Memo, error) { displayTs := memo.CreatedTs instanceMemoRelatedSetting, err := s.Store.GetInstanceMemoRelatedSetting(ctx) if err != nil { return nil, errors.Wrap(err, "failed to get instance memo related setting") } if instanceMemoRelatedSetting.DisplayWithUpdateTime { displayTs = memo.UpdatedTs } name := fmt.Sprintf("%s%s", MemoNamePrefix, memo.UID) memoMessage := &v1pb.Memo{ Name: name, State: convertStateFromStore(memo.RowStatus), Creator: fmt.Sprintf("%s%d", UserNamePrefix, memo.CreatorID), CreateTime: timestamppb.New(time.Unix(memo.CreatedTs, 0)), UpdateTime: timestamppb.New(time.Unix(memo.UpdatedTs, 0)), DisplayTime: timestamppb.New(time.Unix(displayTs, 0)), Content: memo.Content, Visibility: convertVisibilityFromStore(memo.Visibility), Pinned: memo.Pinned, } if memo.Payload != nil { memoMessage.Tags = memo.Payload.Tags memoMessage.Property = convertMemoPropertyFromStore(memo.Payload.Property) memoMessage.Location = convertLocationFromStore(memo.Payload.Location) } if memo.ParentUID != nil { parentName := fmt.Sprintf("%s%s", MemoNamePrefix, *memo.ParentUID) memoMessage.Parent = &parentName } memoMessage.Reactions = []*v1pb.Reaction{} for _, reaction := range reactions { reactionResponse := convertReactionFromStore(reaction) memoMessage.Reactions = append(memoMessage.Reactions, reactionResponse) } if relations != nil { memoMessage.Relations = relations } else { memoMessage.Relations = []*v1pb.MemoRelation{} } memoMessage.Attachments = []*v1pb.Attachment{} for _, attachment := range attachments { attachmentResponse := convertAttachmentFromStore(attachment) memoMessage.Attachments = append(memoMessage.Attachments, attachmentResponse) } snippet, err := s.getMemoContentSnippet(memo.Content) if err != nil { return nil, errors.Wrap(err, "failed to get memo content snippet") } memoMessage.Snippet = snippet return memoMessage, nil } // batchConvertMemoRelations batch-loads relations for a list of memos and returns // a map from memo ID to its converted relations. This avoids N+1 queries when listing memos. func (s *APIV1Service) batchConvertMemoRelations(ctx context.Context, memos []*store.Memo) (map[int32][]*v1pb.MemoRelation, error) { if len(memos) == 0 { return map[int32][]*v1pb.MemoRelation{}, nil } currentUser, err := s.fetchCurrentUser(ctx) if err != nil { return nil, errors.Wrap(err, "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) } memoIDs := make([]int32, len(memos)) memoIDSet := make(map[int32]bool, len(memos)) for i, m := range memos { memoIDs[i] = m.ID memoIDSet[m.ID] = true } // Single batch query to get all relations involving any of these memos. allRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{ MemoIDList: memoIDs, MemoFilter: &memoFilter, }) if err != nil { return nil, errors.Wrap(err, "failed to batch list memo relations") } // Collect all memo IDs referenced in relations that we need to resolve. neededIDs := make(map[int32]bool) for _, r := range allRelations { neededIDs[r.MemoID] = true neededIDs[r.RelatedMemoID] = true } // Build ID→UID map from the memos we already have. memoIDToUID := make(map[int32]string, len(memos)) memoIDToContent := make(map[int32]string, len(memos)) for _, m := range memos { memoIDToUID[m.ID] = m.UID memoIDToContent[m.ID] = m.Content delete(neededIDs, m.ID) } // Batch fetch any additional memos referenced by relations that we don't already have. if len(neededIDs) > 0 { extraIDs := make([]int32, 0, len(neededIDs)) for id := range neededIDs { extraIDs = append(extraIDs, id) } extraMemos, err := s.Store.ListMemos(ctx, &store.FindMemo{IDList: extraIDs}) if err != nil { return nil, errors.Wrap(err, "failed to batch fetch related memos") } for _, m := range extraMemos { memoIDToUID[m.ID] = m.UID memoIDToContent[m.ID] = m.Content } } // Build the result map: memo ID → its relations (both directions). result := make(map[int32][]*v1pb.MemoRelation, len(memos)) for _, r := range allRelations { memoUID, ok1 := memoIDToUID[r.MemoID] relatedUID, ok2 := memoIDToUID[r.RelatedMemoID] if !ok1 || !ok2 { continue } memoSnippet, _ := s.getMemoContentSnippet(memoIDToContent[r.MemoID]) relatedSnippet, _ := s.getMemoContentSnippet(memoIDToContent[r.RelatedMemoID]) relation := &v1pb.MemoRelation{ Memo: &v1pb.MemoRelation_Memo{ Name: fmt.Sprintf("%s%s", MemoNamePrefix, memoUID), Snippet: memoSnippet, }, RelatedMemo: &v1pb.MemoRelation_Memo{ Name: fmt.Sprintf("%s%s", MemoNamePrefix, relatedUID), Snippet: relatedSnippet, }, Type: convertMemoRelationTypeFromStore(r.Type), } // Add to the memo that owns this relation (both directions). if memoIDSet[r.MemoID] { result[r.MemoID] = append(result[r.MemoID], relation) } if memoIDSet[r.RelatedMemoID] { result[r.RelatedMemoID] = append(result[r.RelatedMemoID], relation) } } return result, nil } // loadMemoRelations loads relations for a single memo and converts them to API format. func (s *APIV1Service) loadMemoRelations(ctx context.Context, memo *store.Memo) ([]*v1pb.MemoRelation, error) { relationMap, err := s.batchConvertMemoRelations(ctx, []*store.Memo{memo}) if err != nil { return nil, err } return relationMap[memo.ID], nil } func convertMemoPropertyFromStore(property *storepb.MemoPayload_Property) *v1pb.Memo_Property { if property == nil { return nil } return &v1pb.Memo_Property{ HasLink: property.HasLink, HasTaskList: property.HasTaskList, HasCode: property.HasCode, HasIncompleteTasks: property.HasIncompleteTasks, Title: property.Title, } } func convertLocationFromStore(location *storepb.MemoPayload_Location) *v1pb.Location { if location == nil { return nil } return &v1pb.Location{ Placeholder: location.Placeholder, Latitude: location.Latitude, Longitude: location.Longitude, } } func convertLocationToStore(location *v1pb.Location) *storepb.MemoPayload_Location { if location == nil { return nil } return &storepb.MemoPayload_Location{ Placeholder: location.Placeholder, Latitude: location.Latitude, Longitude: location.Longitude, } } func convertVisibilityFromStore(visibility store.Visibility) v1pb.Visibility { switch visibility { case store.Private: return v1pb.Visibility_PRIVATE case store.Protected: return v1pb.Visibility_PROTECTED case store.Public: return v1pb.Visibility_PUBLIC default: return v1pb.Visibility_VISIBILITY_UNSPECIFIED } } func convertVisibilityToStore(visibility v1pb.Visibility) store.Visibility { switch visibility { case v1pb.Visibility_PROTECTED: return store.Protected case v1pb.Visibility_PUBLIC: return store.Public default: return store.Private } }