Skip to content

armgit / memos

Public Imported from GitHub
0

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.

13.9 KB
Raw Blame
package api

import (
	"context"
	stderrors "errors"
	"fmt"
	"log/slog"
	"time"

	"github.com/pkg/errors"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/timestamppb"

	"github.com/usememos/memos/core/access"
	apipb "github.com/usememos/memos/proto/gen/api"
	storepb "github.com/usememos/memos/proto/gen/store"
	"github.com/usememos/memos/store"
)

var (
	errMemoCreatorNotFound     = stderrors.New("memo creator not found")
	errReactionCreatorNotFound = stderrors.New("reaction creator not found")
)

func (s *APIService) convertMemoFromStore(ctx context.Context, memo *store.Memo, reactions []*store.Reaction, attachments []*store.Attachment, relations []*apipb.MemoRelation) (*apipb.Memo, error) {
	creatorMap, err := s.listUsersByID(ctx, []int32{memo.CreatorID})
	if err != nil {
		return nil, errors.Wrap(err, "failed to list memo creators")
	}
	return s.convertMemoFromStoreWithCreators(ctx, memo, reactions, attachments, relations, creatorMap)
}

func (s *APIService) convertMemoFromStoreWithCreators(ctx context.Context, memo *store.Memo, reactions []*store.Reaction, attachments []*store.Attachment, relations []*apipb.MemoRelation, creatorMap map[int32]*store.User) (*apipb.Memo, error) {
	name := buildMemoName(memo.UID)
	creator := creatorMap[memo.CreatorID]
	if creator == nil {
		return nil, errMemoCreatorNotFound
	}
	memoMessage := &apipb.Memo{
		Name:       name,
		State:      convertStateFromStore(memo.RowStatus),
		Creator:    BuildUserName(creator.Username),
		CreateTime: timestamppb.New(time.Unix(memo.CreatedTs, 0)),
		UpdateTime: timestamppb.New(time.Unix(memo.UpdatedTs, 0)),
		Content:    memo.Content,
		Visibility: convertVisibilityFromStore(memo.Visibility),
		Pinned:     memo.Pinned,
	}
	// An assigned memo needs a read context for its placement projection; an
	// unassigned memo needs none.
	var readContext access.MemoReadContext
	if memo.SpaceID != nil {
		resolved, err := s.buildMemoReadContext(ctx, memo, nil)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve memo access")
		}
		readContext = resolved
	}
	if err := s.projectMemoCollaborationContext(ctx, memo, memoMessage, readContext); err != nil {
		return nil, errors.Wrap(err, "failed to project memo collaboration context")
	}
	if memo.Payload != nil {
		memoMessage.Tags = memo.Payload.Tags
		memoMessage.Property = convertMemoPropertyFromStore(memo.Payload.Property)
		memoMessage.Location = convertLocationFromStore(memo.Payload.Location)
	}

	// Parent identity is part of a readable comment's context. It grants no
	// access to the parent; clients resolve it independently and handle denial.
	if memo.ParentUID != nil {
		parentName := buildMemoName(*memo.ParentUID)
		memoMessage.Parent = &parentName
	}

	// Reactions have no independent audience and are readable whenever this
	// memo is readable. Conversion is reached only after memo authorization.
	reactionMessages, err := s.convertReactionsFromStoreWithCreators(ctx, reactions, creatorMap, name)
	if err != nil {
		return nil, errors.Wrap(err, "failed to convert reactions")
	}
	memoMessage.Reactions = reactionMessages

	if relations != nil {
		memoMessage.Relations = relations
	} else {
		memoMessage.Relations = []*apipb.MemoRelation{}
	}

	memoMessage.Attachments = []*apipb.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
}

func (s *APIService) projectMemoCollaborationContext(ctx context.Context, memo *store.Memo, message *apipb.Memo, readContext access.MemoReadContext) error {
	if memo.SpaceID == nil {
		return nil
	}
	if !readContext.SpaceValid {
		// Placement is not an additional read gate for PRIVATE, PROTECTED, or
		// PUBLIC. Omit a dangling placement rather than turning it into a second
		// audience restriction. SPACE already failed closed in the read policy.
		if memo.Visibility == store.SpaceAudience {
			return errors.New("memo has invalid space placement")
		}
		return nil
	}
	// Placement is visible to the author, to active members, and to an
	// instance administrator; a non-member reading an assigned PUBLIC memo
	// learns nothing about its Space.
	viewer := readContext.Viewer
	if viewer == nil || (viewer.ID != memo.CreatorID && !readContext.ViewerSpaceMember && !access.IsInstanceAdmin(viewer)) {
		return nil
	}
	space, err := s.Store.GetSpace(ctx, &store.FindSpace{ID: memo.SpaceID})
	if err != nil {
		return err
	}
	if space == nil {
		if memo.Visibility == store.SpaceAudience {
			return errors.New("memo has invalid space placement")
		}
		return nil
	}
	spaceName := buildSpaceName(space.UID)
	message.Space = &spaceName
	return nil
}

func (s *APIService) listUsersByIDWithExisting(ctx context.Context, userIDs []int32, existing map[int32]*store.User) (map[int32]*store.User, error) {
	usersByID := make(map[int32]*store.User, len(existing)+len(userIDs))
	for userID, user := range existing {
		if user != nil {
			usersByID[userID] = user
		}
	}

	missingUserIDs := make([]int32, 0, len(userIDs))
	seenMissingUserIDs := make(map[int32]struct{}, len(userIDs))
	for _, userID := range userIDs {
		if _, ok := usersByID[userID]; ok {
			continue
		}
		if _, ok := seenMissingUserIDs[userID]; ok {
			continue
		}
		seenMissingUserIDs[userID] = struct{}{}
		missingUserIDs = append(missingUserIDs, userID)
	}

	if len(missingUserIDs) == 0 {
		return usersByID, nil
	}

	missingUsersByID, err := s.listUsersByID(ctx, missingUserIDs)
	if err != nil {
		return nil, err
	}
	for userID, user := range missingUsersByID {
		if user != nil {
			usersByID[userID] = user
		}
	}
	return usersByID, nil
}

func (s *APIService) convertReactionsFromStoreWithCreators(ctx context.Context, reactions []*store.Reaction, creatorMap map[int32]*store.User, memoName string) ([]*apipb.Reaction, error) {
	if len(reactions) == 0 {
		return []*apipb.Reaction{}, nil
	}

	creatorIDs := make([]int32, 0, len(reactions))
	for _, reaction := range reactions {
		creatorIDs = append(creatorIDs, reaction.CreatorID)
	}
	creatorsByID, err := s.listUsersByIDWithExisting(ctx, creatorIDs, creatorMap)
	if err != nil {
		return nil, err
	}

	reactionMessages := make([]*apipb.Reaction, 0, len(reactions))
	for _, reaction := range reactions {
		reactionMessage, err := convertReactionFromStoreWithCreators(reaction, creatorsByID, memoName)
		if err != nil {
			if stderrors.Is(err, errReactionCreatorNotFound) {
				slog.Warn("Skipping reaction with missing creator",
					slog.Int64("reaction_id", int64(reaction.ID)),
					slog.Int64("creator_id", int64(reaction.CreatorID)),
					slog.Int64("memo_id", int64(reaction.MemoID)),
				)
				continue
			}
			return nil, err
		}
		reactionMessages = append(reactionMessages, reactionMessage)
	}
	return reactionMessages, nil
}

func convertReactionFromStoreWithCreators(reaction *store.Reaction, creatorsByID map[int32]*store.User, memoName string) (*apipb.Reaction, error) {
	creator := creatorsByID[reaction.CreatorID]
	if creator == nil {
		return nil, errReactionCreatorNotFound
	}

	reactionUID := fmt.Sprintf("%d", reaction.ID)
	return &apipb.Reaction{
		Name:         fmt.Sprintf("%s/%s%s", memoName, ReactionNamePrefix, reactionUID),
		Creator:      BuildUserName(creator.Username),
		ReactionType: reaction.ReactionType,
		CreateTime:   timestamppb.New(time.Unix(reaction.CreatedTs, 0)),
	}, 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 *APIService) batchConvertMemoRelations(ctx context.Context, memos []*store.Memo, includeSnippets bool) (map[int32][]*apipb.MemoRelation, error) {
	if len(memos) == 0 {
		return map[int32][]*apipb.MemoRelation{}, nil
	}

	accessScope, _, err := s.resolveMemoAccessScope(ctx)
	if err != nil {
		return nil, err
	}

	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
	}

	outgoingRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{
		SourceMemoIDList: memoIDs,
	})
	if err != nil {
		return nil, errors.Wrap(err, "failed to batch list outgoing memo relations")
	}
	incomingRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{
		RelatedMemoIDList: memoIDs,
	})
	if err != nil {
		return nil, errors.Wrap(err, "failed to batch list incoming memo relations")
	}
	allRelations := mergeMemoRelations(outgoingRelations, incomingRelations)

	// 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))
	memoIDToSnippet := make(map[int32]string, len(memos))
	for _, m := range memos {
		memoIDToUID[m.ID] = m.UID
		if includeSnippets {
			snippet, err := s.getMemoContentSnippet(m.Content)
			if err != nil {
				return nil, errors.Wrap(err, "failed to get memo content snippet")
			}
			memoIDToSnippet[m.ID] = snippet
		}
		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)
		}
		extraFind := &store.FindMemo{IDList: extraIDs, ExcludeContent: !includeSnippets, Access: accessScope}
		extraMemos, err := s.Store.ListMemos(ctx, extraFind)
		if err != nil {
			return nil, errors.Wrap(err, "failed to batch fetch related memos")
		}
		for _, m := range extraMemos {
			memoIDToUID[m.ID] = m.UID
			if includeSnippets {
				snippet, err := s.getMemoContentSnippet(m.Content)
				if err != nil {
					return nil, errors.Wrap(err, "failed to get related memo content snippet")
				}
				memoIDToSnippet[m.ID] = snippet
			}
		}
	}

	// Build the result map: memo ID → its relations (both directions).
	result := make(map[int32][]*apipb.MemoRelation, len(memos))
	for _, r := range allRelations {
		memoUID, ok1 := memoIDToUID[r.MemoID]
		relatedUID, ok2 := memoIDToUID[r.RelatedMemoID]
		if !ok1 || !ok2 {
			continue
		}

		relation := &apipb.MemoRelation{
			Memo: &apipb.MemoRelation_MemoRef{
				Name:    fmt.Sprintf("%s%s", MemoNamePrefix, memoUID),
				Snippet: memoIDToSnippet[r.MemoID],
			},
			RelatedMemo: &apipb.MemoRelation_MemoRef{
				Name:    fmt.Sprintf("%s%s", MemoNamePrefix, relatedUID),
				Snippet: memoIDToSnippet[r.RelatedMemoID],
			},
			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 *APIService) loadMemoRelations(ctx context.Context, memo *store.Memo) ([]*apipb.MemoRelation, error) {
	relationMap, err := s.batchConvertMemoRelations(ctx, []*store.Memo{memo}, true)
	if err != nil {
		return nil, err
	}
	return relationMap[memo.ID], nil
}

func mergeMemoRelations(groups ...[]*store.MemoRelation) []*store.MemoRelation {
	seen := make(map[string]struct{})
	merged := make([]*store.MemoRelation, 0)
	for _, relations := range groups {
		for _, relation := range relations {
			key := fmt.Sprintf("%d:%d:%s", relation.MemoID, relation.RelatedMemoID, relation.Type)
			if _, ok := seen[key]; ok {
				continue
			}
			seen[key] = struct{}{}
			merged = append(merged, relation)
		}
	}
	return merged
}

func convertMemoPropertyFromStore(property *storepb.MemoPayload_Property) *apipb.Memo_Property {
	if property == nil {
		return nil
	}
	return &apipb.Memo_Property{
		HasLink:            property.HasLink,
		HasTaskList:        property.HasTaskList,
		HasCode:            property.HasCode,
		HasIncompleteTasks: property.HasIncompleteTasks,
		HasInlineImage:     property.HasInlineImage,
		Title:              property.Title,
	}
}

func convertLocationFromStore(location *storepb.MemoPayload_Location) *apipb.Location {
	if location == nil {
		return nil
	}
	return &apipb.Location{
		Placeholder: location.Placeholder,
		Latitude:    location.Latitude,
		Longitude:   location.Longitude,
	}
}

func convertLocationToStore(location *apipb.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) apipb.Visibility {
	switch visibility {
	case store.Private:
		return apipb.Visibility_PRIVATE
	case store.Protected:
		return apipb.Visibility_PROTECTED
	case store.Public:
		return apipb.Visibility_PUBLIC
	case store.SpaceAudience:
		return apipb.Visibility_SPACE
	default:
		return apipb.Visibility_VISIBILITY_UNSPECIFIED
	}
}

func validateCreateMemoVisibility(visibility apipb.Visibility) (store.Visibility, error) {
	switch visibility {
	case apipb.Visibility_VISIBILITY_UNSPECIFIED, apipb.Visibility_PRIVATE:
		return store.Private, nil
	case apipb.Visibility_PROTECTED:
		return store.Protected, nil
	case apipb.Visibility_PUBLIC:
		return store.Public, nil
	case apipb.Visibility_SPACE:
		return store.SpaceAudience, nil
	default:
		return "", status.Errorf(codes.InvalidArgument, "invalid memo visibility")
	}
}

func validateUpdateMemoVisibility(visibility apipb.Visibility) (store.Visibility, error) {
	if visibility == apipb.Visibility_VISIBILITY_UNSPECIFIED {
		return "", status.Errorf(codes.InvalidArgument, "visibility must be specified")
	}
	return validateCreateMemoVisibility(visibility)
}