refactor: memo store (#1741)

api/memo.go

@@ -1,8 +1,5 @@
 package api
 
-// MaxContentLength means the max memo content bytes is 1MB.
-const MaxContentLength = 1 << 30
-
 // Visibility is the type of a visibility.
 type Visibility string
 
@@ -15,8 +12,8 @@ const (
 	Private Visibility = "PRIVATE"
 )
 
-func (e Visibility) String() string {
+func (v Visibility) String() string {
-	switch e {
+	switch v {
 	case Public:
 		return "PUBLIC"
 	case Protected:
@@ -27,7 +24,7 @@ func (e Visibility) String() string {
 	return "PRIVATE"
 }
 
-type Memo struct {
+type MemoResponse struct {
 	ID int `json:"id"`
 
 	// Standard fields
@@ -43,11 +40,12 @@ type Memo struct {
 
 	// Related fields
 	CreatorName    string `json:"creatorName"`
+	ResourceIDList []int
 	ResourceList   []*Resource     `json:"resourceList"`
 	RelationList   []*MemoRelation `json:"relationList"`
 }
 
-type MemoCreate struct {
+type CreateMemoRequest struct {
 	// Standard fields
 	CreatorID int    `json:"-"`
 	CreatedTs *int64 `json:"createdTs"`
@@ -61,7 +59,7 @@ type MemoCreate struct {
 	RelationList   []*MemoRelationUpsert `json:"relationList"`
 }
 
-type MemoPatch struct {
+type PatchMemoRequest struct {
 	ID int `json:"-"`
 
 	// Standard fields
@@ -78,7 +76,7 @@ type MemoPatch struct {
 	RelationList   []*MemoRelationUpsert `json:"relationList"`
 }
 
-type MemoFind struct {
+type FindMemoRequest struct {
 	ID *int
 
 	// Standard fields
@@ -94,7 +92,3 @@ type MemoFind struct {
 	Limit  *int
 	Offset *int
 }
-
-type MemoDelete struct {
-	ID int
-}

server/memo.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -16,6 +17,9 @@ import (
 	"github.com/labstack/echo/v4"
 )
 
+// maxContentLength means the max memo content bytes is 1MB.
+const maxContentLength = 1 << 30
+
 func (s *Server) registerMemoRoutes(g *echo.Group) {
 	g.POST("/memo", func(c echo.Context) error {
 		ctx := c.Request().Context()
@@ -24,12 +28,15 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusUnauthorized, "Missing user in session")
 		}
 
-		memoCreate := &api.MemoCreate{}
+		createMemoRequest := &api.CreateMemoRequest{}
-		if err := json.NewDecoder(c.Request().Body).Decode(memoCreate); err != nil {
+		if err := json.NewDecoder(c.Request().Body).Decode(createMemoRequest); err != nil {
 			return echo.NewHTTPError(http.StatusBadRequest, "Malformatted post memo request").SetInternal(err)
 		}
+		if len(createMemoRequest.Content) > maxContentLength {
+			return echo.NewHTTPError(http.StatusBadRequest, "Content size overflow, up to 1MB")
+		}
 
-		if memoCreate.Visibility == "" {
+		if createMemoRequest.Visibility == "" {
 			userMemoVisibilitySetting, err := s.Store.FindUserSetting(ctx, &api.UserSettingFind{
 				UserID: userID,
 				Key:    api.UserSettingMemoVisibilityKey,
@@ -44,14 +51,14 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 				if err != nil {
 					return echo.NewHTTPError(http.StatusInternalServerError, "Failed to unmarshal user setting value").SetInternal(err)
 				}
-				memoCreate.Visibility = memoVisibility
+				createMemoRequest.Visibility = memoVisibility
 			} else {
 				// Private is the default memo visibility.
-				memoCreate.Visibility = api.Private
+				createMemoRequest.Visibility = api.Private
 			}
 		}
 
-		// Find system settings
+		// Find disable public memos system setting.
 		disablePublicMemosSystemSetting, err := s.Store.FindSystemSetting(ctx, &api.SystemSettingFind{
 			Name: api.SystemSettingDisablePublicMemosName,
 		})
@@ -65,46 +72,40 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 				return echo.NewHTTPError(http.StatusInternalServerError, "Failed to unmarshal system setting").SetInternal(err)
 			}
 			if disablePublicMemos {
-				// Allow if the user is an admin.
 				user, err := s.Store.FindUser(ctx, &api.UserFind{
 					ID: &userID,
 				})
 				if err != nil {
 					return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find user").SetInternal(err)
 				}
-				// Only enforce private if you're a regular user.
+				// Enforce normal user to create private memo if public memos are disabled.
-				// Admins should know what they're doing.
 				if user.Role == "USER" {
-					memoCreate.Visibility = api.Private
+					createMemoRequest.Visibility = api.Private
 				}
 			}
 		}
 
-		if len(memoCreate.Content) > api.MaxContentLength {
+		createMemoRequest.CreatorID = userID
-			return echo.NewHTTPError(http.StatusBadRequest, "Content size overflow, up to 1MB").SetInternal(err)
+		memoMessage, err := s.Store.CreateMemo(ctx, convertCreateMemoRequestToMemoMessage(createMemoRequest))
-		}
-
-		memoCreate.CreatorID = userID
-		memo, err := s.Store.CreateMemo(ctx, memoCreate)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create memo").SetInternal(err)
 		}
-		if err := s.createMemoCreateActivity(c, memo); err != nil {
+		if err := s.createMemoCreateActivity(c, memoMessage); err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to create activity").SetInternal(err)
 		}
 
-		for _, resourceID := range memoCreate.ResourceIDList {
+		for _, resourceID := range createMemoRequest.ResourceIDList {
 			if _, err := s.Store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{
-				MemoID:     memo.ID,
+				MemoID:     memoMessage.ID,
 				ResourceID: resourceID,
 			}); err != nil {
 				return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo resource").SetInternal(err)
 			}
 		}
 
-		for _, memoRelationUpsert := range memoCreate.RelationList {
+		for _, memoRelationUpsert := range createMemoRequest.RelationList {
 			if _, err := s.Store.UpsertMemoRelation(ctx, &store.MemoRelationMessage{
-				MemoID:        memo.ID,
+				MemoID:        memoMessage.ID,
 				RelatedMemoID: memoRelationUpsert.RelatedMemoID,
 				Type:          store.MemoRelationType(memoRelationUpsert.Type),
 			}); err != nil {
@@ -112,11 +113,17 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			}
 		}
 
-		memo, err = s.Store.ComposeMemo(ctx, memo)
+		memoMessage, err = s.Store.GetMemo(ctx, &store.FindMemoMessage{
+			ID: &memoMessage.ID,
+		})
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo").SetInternal(err)
 		}
-		return c.JSON(http.StatusOK, composeResponse(memo))
+		memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
+		if err != nil {
+			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
+		}
+		return c.JSON(http.StatusOK, composeResponse(memoResponse))
 	})
 
 	g.PATCH("/memo/:memoId", func(c echo.Context) error {
@@ -131,47 +138,58 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err)
 		}
 
-		memo, err := s.Store.FindMemo(ctx, &api.MemoFind{
+		memoMessage, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
 			ID: &memoID,
 		})
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo").SetInternal(err)
 		}
-		if memo.CreatorID != userID {
+		if memoMessage.CreatorID != userID {
 			return echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized")
 		}
 
 		currentTs := time.Now().Unix()
-		memoPatch := &api.MemoPatch{
+		patchMemoRequest := &api.PatchMemoRequest{
 			ID:        memoID,
 			UpdatedTs: &currentTs,
 		}
-		if err := json.NewDecoder(c.Request().Body).Decode(memoPatch); err != nil {
+		if err := json.NewDecoder(c.Request().Body).Decode(patchMemoRequest); err != nil {
 			return echo.NewHTTPError(http.StatusBadRequest, "Malformatted patch memo request").SetInternal(err)
 		}
 
-		if memoPatch.Content != nil && len(*memoPatch.Content) > api.MaxContentLength {
+		if patchMemoRequest.Content != nil && len(*patchMemoRequest.Content) > maxContentLength {
 			return echo.NewHTTPError(http.StatusBadRequest, "Content size overflow, up to 1MB").SetInternal(err)
 		}
 
-		memo, err = s.Store.PatchMemo(ctx, memoPatch)
+		updateMemoMessage := &store.UpdateMemoMessage{
+			ID:        memoID,
+			CreatedTs: patchMemoRequest.CreatedTs,
+			UpdatedTs: patchMemoRequest.UpdatedTs,
+			Content:   patchMemoRequest.Content,
+		}
+		if patchMemoRequest.RowStatus != nil {
+			rowStatus := store.RowStatus(patchMemoRequest.RowStatus.String())
+			updateMemoMessage.RowStatus = &rowStatus
+		}
+		if patchMemoRequest.Visibility != nil {
+			visibility := store.Visibility(patchMemoRequest.Visibility.String())
+			updateMemoMessage.Visibility = &visibility
+		}
+
+		err = s.Store.UpdateMemo(ctx, updateMemoMessage)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to patch memo").SetInternal(err)
 		}
-		memo, err = s.Store.ComposeMemo(ctx, memo)
+		memoMessage, err = s.Store.GetMemo(ctx, &store.FindMemoMessage{ID: &memoID})
 		if err != nil {
-			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo").SetInternal(err)
+			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo").SetInternal(err)
 		}
 
-		if memoPatch.ResourceIDList != nil {
+		if patchMemoRequest.ResourceIDList != nil {
-			resourceIDList := make([]int, 0)
+			addedResourceIDList, removedResourceIDList := getIDListDiff(memoMessage.ResourceIDList, patchMemoRequest.ResourceIDList)
-			for _, resource := range memo.ResourceList {
-				resourceIDList = append(resourceIDList, resource.ID)
-			}
-			addedResourceIDList, removedResourceIDList := getIDListDiff(resourceIDList, memoPatch.ResourceIDList)
 			for _, resourceID := range addedResourceIDList {
 				if _, err := s.Store.UpsertMemoResource(ctx, &api.MemoResourceUpsert{
-					MemoID:     memo.ID,
+					MemoID:     memoMessage.ID,
 					ResourceID: resourceID,
 				}); err != nil {
 					return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo resource").SetInternal(err)
@@ -179,7 +197,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			}
 			for _, resourceID := range removedResourceIDList {
 				if err := s.Store.DeleteMemoResource(ctx, &api.MemoResourceDelete{
-					MemoID:     &memo.ID,
+					MemoID:     &memoMessage.ID,
 					ResourceID: &resourceID,
 				}); err != nil {
 					return echo.NewHTTPError(http.StatusInternalServerError, "Failed to delete memo resource").SetInternal(err)
@@ -187,100 +205,106 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			}
 		}
 
-		if memoPatch.RelationList != nil {
+		if patchMemoRequest.RelationList != nil {
-			patchMemoRelationList := make([]*api.MemoRelation, 0)
+			patchMemoRelationList := make([]*store.MemoRelationMessage, 0)
-			for _, memoRelationUpsert := range memoPatch.RelationList {
+			for _, memoRelation := range patchMemoRequest.RelationList {
-				patchMemoRelationList = append(patchMemoRelationList, &api.MemoRelation{
+				patchMemoRelationList = append(patchMemoRelationList, &store.MemoRelationMessage{
-					MemoID:        memo.ID,
+					MemoID:        memoMessage.ID,
-					RelatedMemoID: memoRelationUpsert.RelatedMemoID,
-					Type:          memoRelationUpsert.Type,
-				})
-			}
-			addedMemoRelationList, removedMemoRelationList := getMemoRelationListDiff(memo.RelationList, patchMemoRelationList)
-			for _, memoRelation := range addedMemoRelationList {
-				if _, err := s.Store.UpsertMemoRelation(ctx, &store.MemoRelationMessage{
-					MemoID:        memo.ID,
 					RelatedMemoID: memoRelation.RelatedMemoID,
 					Type:          store.MemoRelationType(memoRelation.Type),
-				}); err != nil {
+				})
+			}
+			addedMemoRelationList, removedMemoRelationList := getMemoRelationListDiff(memoMessage.RelationList, patchMemoRelationList)
+			for _, memoRelation := range addedMemoRelationList {
+				if _, err := s.Store.UpsertMemoRelation(ctx, memoRelation); err != nil {
 					return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo relation").SetInternal(err)
 				}
 			}
 			for _, memoRelation := range removedMemoRelationList {
-				memoRelationType := store.MemoRelationType(memoRelation.Type)
 				if err := s.Store.DeleteMemoRelation(ctx, &store.DeleteMemoRelationMessage{
-					MemoID:        &memo.ID,
+					MemoID:        &memoMessage.ID,
 					RelatedMemoID: &memoRelation.RelatedMemoID,
-					Type:          &memoRelationType,
+					Type:          &memoRelation.Type,
 				}); err != nil {
 					return echo.NewHTTPError(http.StatusInternalServerError, "Failed to delete memo relation").SetInternal(err)
 				}
 			}
 		}
 
-		// After patching memo resources and relations, we need to re-compose it to get the latest data.
+		memoMessage, err = s.Store.GetMemo(ctx, &store.FindMemoMessage{ID: &memoID})
-		memo, err = s.Store.ComposeMemo(ctx, memo)
 		if err != nil {
-			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo").SetInternal(err)
+			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo").SetInternal(err)
 		}
-		return c.JSON(http.StatusOK, composeResponse(memo))
+		memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
+		if err != nil {
+			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
+		}
+		return c.JSON(http.StatusOK, composeResponse(memoResponse))
 	})
 
 	g.GET("/memo", func(c echo.Context) error {
 		ctx := c.Request().Context()
-		memoFind := &api.MemoFind{}
+		findMemoMessage := &store.FindMemoMessage{}
 		if userID, err := strconv.Atoi(c.QueryParam("creatorId")); err == nil {
-			memoFind.CreatorID = &userID
+			findMemoMessage.CreatorID = &userID
 		}
 
 		currentUserID, ok := c.Get(getUserIDContextKey()).(int)
 		if !ok {
-			if memoFind.CreatorID == nil {
+			if findMemoMessage.CreatorID == nil {
 				return echo.NewHTTPError(http.StatusBadRequest, "Missing user id to find memo")
 			}
-			memoFind.VisibilityList = []api.Visibility{api.Public}
+			findMemoMessage.VisibilityList = []store.Visibility{store.Public}
 		} else {
-			if memoFind.CreatorID == nil {
+			if findMemoMessage.CreatorID == nil {
-				memoFind.CreatorID = &currentUserID
+				findMemoMessage.CreatorID = &currentUserID
 			} else {
-				memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected}
+				findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected}
 			}
 		}
 
-		rowStatus := api.RowStatus(c.QueryParam("rowStatus"))
+		rowStatus := store.RowStatus(c.QueryParam("rowStatus"))
 		if rowStatus != "" {
-			memoFind.RowStatus = &rowStatus
+			findMemoMessage.RowStatus = &rowStatus
 		}
 		pinnedStr := c.QueryParam("pinned")
 		if pinnedStr != "" {
 			pinned := pinnedStr == "true"
-			memoFind.Pinned = &pinned
+			findMemoMessage.Pinned = &pinned
 		}
 		tag := c.QueryParam("tag")
 		if tag != "" {
 			contentSearch := "#" + tag
-			memoFind.ContentSearch = &contentSearch
+			findMemoMessage.ContentSearch = &contentSearch
 		}
 		visibilityListStr := c.QueryParam("visibility")
 		if visibilityListStr != "" {
-			visibilityList := []api.Visibility{}
+			visibilityList := []store.Visibility{}
 			for _, visibility := range strings.Split(visibilityListStr, ",") {
-				visibilityList = append(visibilityList, api.Visibility(visibility))
+				visibilityList = append(visibilityList, store.Visibility(visibility))
 			}
-			memoFind.VisibilityList = visibilityList
+			findMemoMessage.VisibilityList = visibilityList
 		}
 		if limit, err := strconv.Atoi(c.QueryParam("limit")); err == nil {
-			memoFind.Limit = &limit
+			findMemoMessage.Limit = &limit
 		}
 		if offset, err := strconv.Atoi(c.QueryParam("offset")); err == nil {
-			memoFind.Offset = &offset
+			findMemoMessage.Offset = &offset
 		}
 
-		list, err := s.Store.FindMemoList(ctx, memoFind)
+		memoMessageList, err := s.Store.ListMemos(ctx, findMemoMessage)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch memo list").SetInternal(err)
 		}
-		return c.JSON(http.StatusOK, composeResponse(list))
+		memoResponseList := []*api.MemoResponse{}
+		for _, memoMessage := range memoMessageList {
+			memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
+			if err != nil {
+				return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
+			}
+			memoResponseList = append(memoResponseList, memoResponse)
+		}
+		return c.JSON(http.StatusOK, composeResponse(memoResponseList))
 	})
 
 	g.GET("/memo/:memoId", func(c echo.Context) error {
@@ -290,29 +314,31 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err)
 		}
 
-		memoFind := &api.MemoFind{
+		memoMessage, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
 			ID: &memoID,
-		}
+		})
-		memo, err := s.Store.FindMemo(ctx, memoFind)
 		if err != nil {
 			if common.ErrorCode(err) == common.NotFound {
 				return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID)).SetInternal(err)
 			}
-
 			return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to find memo by ID: %v", memoID)).SetInternal(err)
 		}
 
 		userID, ok := c.Get(getUserIDContextKey()).(int)
-		if memo.Visibility == api.Private {
+		if memoMessage.Visibility == store.Private {
-			if !ok || memo.CreatorID != userID {
+			if !ok || memoMessage.CreatorID != userID {
 				return echo.NewHTTPError(http.StatusForbidden, "this memo is private only")
 			}
-		} else if memo.Visibility == api.Protected {
+		} else if memoMessage.Visibility == store.Protected {
 			if !ok {
 				return echo.NewHTTPError(http.StatusForbidden, "this memo is protected, missing user in session")
 			}
 		}
-		return c.JSON(http.StatusOK, composeResponse(memo))
+		memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
+		if err != nil {
+			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
+		}
+		return c.JSON(http.StatusOK, composeResponse(memoResponse))
 	})
 
 	g.POST("/memo/:memoId/organizer", func(c echo.Context) error {
@@ -338,46 +364,49 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to upsert memo organizer").SetInternal(err)
 		}
 
-		memo, err := s.Store.FindMemo(ctx, &api.MemoFind{
+		memoMessage, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
 			ID: &memoID,
 		})
 		if err != nil {
 			if common.ErrorCode(err) == common.NotFound {
 				return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID)).SetInternal(err)
 			}
-
 			return echo.NewHTTPError(http.StatusInternalServerError, fmt.Sprintf("Failed to find memo by ID: %v", memoID)).SetInternal(err)
 		}
-		return c.JSON(http.StatusOK, composeResponse(memo))
+		memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
+		if err != nil {
+			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
+		}
+		return c.JSON(http.StatusOK, composeResponse(memoResponse))
 	})
 
 	g.GET("/memo/stats", func(c echo.Context) error {
 		ctx := c.Request().Context()
-		normalStatus := api.Normal
+		normalStatus := store.Normal
-		memoFind := &api.MemoFind{
+		findMemoMessage := &store.FindMemoMessage{
 			RowStatus: &normalStatus,
 		}
 		if creatorID, err := strconv.Atoi(c.QueryParam("creatorId")); err == nil {
-			memoFind.CreatorID = &creatorID
+			findMemoMessage.CreatorID = &creatorID
 		}
-		if memoFind.CreatorID == nil {
+		if findMemoMessage.CreatorID == nil {
 			return echo.NewHTTPError(http.StatusBadRequest, "Missing user id to find memo")
 		}
 
 		currentUserID, ok := c.Get(getUserIDContextKey()).(int)
 		if !ok {
-			memoFind.VisibilityList = []api.Visibility{api.Public}
+			findMemoMessage.VisibilityList = []store.Visibility{store.Public}
 		} else {
-			if *memoFind.CreatorID != currentUserID {
+			if *findMemoMessage.CreatorID != currentUserID {
-				memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected}
+				findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected}
 			} else {
-				memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected, api.Private}
+				findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected, store.Private}
 			}
 		}
 
-		list, err := s.Store.FindMemoList(ctx, memoFind)
+		list, err := s.Store.ListMemos(ctx, findMemoMessage)
 		if err != nil {
-			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch memo list").SetInternal(err)
+			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
 		}
 
 		createdTsList := []int64{}
@@ -389,49 +418,56 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 
 	g.GET("/memo/all", func(c echo.Context) error {
 		ctx := c.Request().Context()
-		memoFind := &api.MemoFind{}
+		findMemoMessage := &store.FindMemoMessage{}
-
 		_, ok := c.Get(getUserIDContextKey()).(int)
 		if !ok {
-			memoFind.VisibilityList = []api.Visibility{api.Public}
+			findMemoMessage.VisibilityList = []store.Visibility{store.Public}
 		} else {
-			memoFind.VisibilityList = []api.Visibility{api.Public, api.Protected}
+			findMemoMessage.VisibilityList = []store.Visibility{store.Public, store.Protected}
 		}
 
 		pinnedStr := c.QueryParam("pinned")
 		if pinnedStr != "" {
 			pinned := pinnedStr == "true"
-			memoFind.Pinned = &pinned
+			findMemoMessage.Pinned = &pinned
 		}
 		tag := c.QueryParam("tag")
 		if tag != "" {
 			contentSearch := "#" + tag + " "
-			memoFind.ContentSearch = &contentSearch
+			findMemoMessage.ContentSearch = &contentSearch
 		}
 		visibilityListStr := c.QueryParam("visibility")
 		if visibilityListStr != "" {
-			visibilityList := []api.Visibility{}
+			visibilityList := []store.Visibility{}
 			for _, visibility := range strings.Split(visibilityListStr, ",") {
-				visibilityList = append(visibilityList, api.Visibility(visibility))
+				visibilityList = append(visibilityList, store.Visibility(visibility))
 			}
-			memoFind.VisibilityList = visibilityList
+			findMemoMessage.VisibilityList = visibilityList
 		}
 		if limit, err := strconv.Atoi(c.QueryParam("limit")); err == nil {
-			memoFind.Limit = &limit
+			findMemoMessage.Limit = &limit
 		}
 		if offset, err := strconv.Atoi(c.QueryParam("offset")); err == nil {
-			memoFind.Offset = &offset
+			findMemoMessage.Offset = &offset
 		}
 
 		// Only fetch normal status memos.
-		normalStatus := api.Normal
+		normalStatus := store.Normal
-		memoFind.RowStatus = &normalStatus
+		findMemoMessage.RowStatus = &normalStatus
 
-		list, err := s.Store.FindMemoList(ctx, memoFind)
+		memoMessageList, err := s.Store.ListMemos(ctx, findMemoMessage)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to fetch all memo list").SetInternal(err)
 		}
-		return c.JSON(http.StatusOK, composeResponse(list))
+		memoResponseList := []*api.MemoResponse{}
+		for _, memoMessage := range memoMessageList {
+			memoResponse, err := s.ComposeMemoResponse(ctx, convertMemoMessageToMemoResponse(memoMessage))
+			if err != nil {
+				return echo.NewHTTPError(http.StatusInternalServerError, "Failed to compose memo response").SetInternal(err)
+			}
+			memoResponseList = append(memoResponseList, memoResponse)
+		}
+		return c.JSON(http.StatusOK, composeResponse(memoResponseList))
 	})
 
 	g.DELETE("/memo/:memoId", func(c echo.Context) error {
@@ -445,7 +481,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("ID is not a number: %s", c.Param("memoId"))).SetInternal(err)
 		}
 
-		memo, err := s.Store.FindMemo(ctx, &api.MemoFind{
+		memo, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
 			ID: &memoID,
 		})
 		if err != nil {
@@ -455,10 +491,9 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized")
 		}
 
-		memoDelete := &api.MemoDelete{
+		if err := s.Store.DeleteMemo(ctx, &store.DeleteMemoMessage{
 			ID: memoID,
-		}
+		}); err != nil {
-		if err := s.Store.DeleteMemo(ctx, memoDelete); err != nil {
 			if common.ErrorCode(err) == common.NotFound {
 				return echo.NewHTTPError(http.StatusNotFound, fmt.Sprintf("Memo ID not found: %d", memoID))
 			}
@@ -468,7 +503,7 @@ func (s *Server) registerMemoRoutes(g *echo.Group) {
 	})
 }
 
-func (s *Server) createMemoCreateActivity(c echo.Context, memo *api.Memo) error {
+func (s *Server) createMemoCreateActivity(c echo.Context, memo *store.MemoMessage) error {
 	ctx := c.Request().Context()
 	payload := api.ActivityMemoCreatePayload{
 		Content:    memo.Content,
@@ -512,7 +547,7 @@ func getIDListDiff(oldList, newList []int) (addedList, removedList []int) {
 	return addedList, removedList
 }
 
-func getMemoRelationListDiff(oldList, newList []*api.MemoRelation) (addedList, removedList []*api.MemoRelation) {
+func getMemoRelationListDiff(oldList, newList []*store.MemoRelationMessage) (addedList, removedList []*store.MemoRelationMessage) {
 	oldMap := map[string]bool{}
 	for _, relation := range oldList {
 		oldMap[fmt.Sprintf("%d-%s", relation.RelatedMemoID, relation.Type)] = true
@@ -535,3 +570,64 @@ func getMemoRelationListDiff(oldList, newList []*api.MemoRelation) (addedList, r
 	}
 	return addedList, removedList
 }
+
+func convertCreateMemoRequestToMemoMessage(memoCreate *api.CreateMemoRequest) *store.MemoMessage {
+	createdTs := time.Now().Unix()
+	if memoCreate.CreatedTs != nil {
+		createdTs = *memoCreate.CreatedTs
+	}
+	return &store.MemoMessage{
+		CreatorID:  memoCreate.CreatorID,
+		CreatedTs:  createdTs,
+		Content:    memoCreate.Content,
+		Visibility: store.Visibility(memoCreate.Visibility),
+	}
+}
+
+func convertMemoMessageToMemoResponse(memoMessage *store.MemoMessage) *api.MemoResponse {
+	relationList := []*api.MemoRelation{}
+	for _, relation := range memoMessage.RelationList {
+		relationList = append(relationList, convertMemoRelationMessageToMemoRelation(relation))
+	}
+
+	return &api.MemoResponse{
+		ID:             memoMessage.ID,
+		RowStatus:      api.RowStatus(memoMessage.RowStatus.String()),
+		CreatorID:      memoMessage.CreatorID,
+		CreatedTs:      memoMessage.CreatedTs,
+		UpdatedTs:      memoMessage.UpdatedTs,
+		Content:        memoMessage.Content,
+		Visibility:     api.Visibility(memoMessage.Visibility.String()),
+		Pinned:         memoMessage.Pinned,
+		ResourceIDList: memoMessage.ResourceIDList,
+		RelationList:   relationList,
+	}
+}
+
+func (s *Server) ComposeMemoResponse(ctx context.Context, memoResponse *api.MemoResponse) (*api.MemoResponse, error) {
+	user, err := s.Store.FindUser(ctx, &api.UserFind{
+		ID: &memoResponse.CreatorID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if user.Nickname != "" {
+		memoResponse.CreatorName = user.Nickname
+	} else {
+		memoResponse.CreatorName = user.Username
+	}
+
+	memoResponse.ResourceList = []*api.Resource{}
+	for _, resourceID := range memoResponse.ResourceIDList {
+		resource, err := s.Store.FindResource(ctx, &api.ResourceFind{
+			ID: &resourceID,
+		})
+		if err != nil {
+			return nil, err
+		}
+		memoResponse.ResourceList = append(memoResponse.ResourceList, resource)
+	}
+
+	return memoResponse, nil
+}

server/memo_relation.go

@@ -74,3 +74,11 @@ func (s *Server) registerMemoRelationRoutes(g *echo.Group) {
 		return c.JSON(http.StatusOK, true)
 	})
 }
+
+func convertMemoRelationMessageToMemoRelation(memoRelation *store.MemoRelationMessage) *api.MemoRelation {
+	return &api.MemoRelation{
+		MemoID:        memoRelation.MemoID,
+		RelatedMemoID: memoRelation.RelatedMemoID,
+		Type:          api.MemoRelationType(memoRelation.Type),
+	}
+}

server/memo_resource.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/usememos/memos/api"
+	"github.com/usememos/memos/store"
 
 	"github.com/labstack/echo/v4"
 )
@@ -82,7 +83,7 @@ func (s *Server) registerMemoResourceRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Resource ID is not a number: %s", c.Param("resourceId"))).SetInternal(err)
 		}
 
-		memo, err := s.Store.FindMemo(ctx, &api.MemoFind{
+		memo, err := s.Store.GetMemo(ctx, &store.FindMemoMessage{
 			ID: &memoID,
 		})
 		if err != nil {

server/rss.go

@@ -13,6 +13,7 @@ import (
 	"github.com/labstack/echo/v4"
 	"github.com/usememos/memos/api"
 	"github.com/usememos/memos/common"
+	"github.com/usememos/memos/store"
 	"github.com/yuin/goldmark"
 )
 
@@ -24,12 +25,12 @@ func (s *Server) registerRSSRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get system customized profile").SetInternal(err)
 		}
 
-		normalStatus := api.Normal
+		normalStatus := store.Normal
-		memoFind := api.MemoFind{
+		memoFind := store.FindMemoMessage{
 			RowStatus:      &normalStatus,
-			VisibilityList: []api.Visibility{api.Public},
+			VisibilityList: []store.Visibility{store.Public},
 		}
-		memoList, err := s.Store.FindMemoList(ctx, &memoFind)
+		memoList, err := s.Store.ListMemos(ctx, &memoFind)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
 		}
@@ -55,13 +56,13 @@ func (s *Server) registerRSSRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to get system customized profile").SetInternal(err)
 		}
 
-		normalStatus := api.Normal
+		normalStatus := store.Normal
-		memoFind := api.MemoFind{
+		memoFind := store.FindMemoMessage{
 			CreatorID:      &id,
 			RowStatus:      &normalStatus,
-			VisibilityList: []api.Visibility{api.Public},
+			VisibilityList: []store.Visibility{store.Public},
 		}
-		memoList, err := s.Store.FindMemoList(ctx, &memoFind)
+		memoList, err := s.Store.ListMemos(ctx, &memoFind)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
 		}
@@ -79,7 +80,7 @@ func (s *Server) registerRSSRoutes(g *echo.Group) {
 const MaxRSSItemCount = 100
 const MaxRSSItemTitleLength = 100
 
-func (s *Server) generateRSSFromMemoList(ctx context.Context, memoList []*api.Memo, baseURL string, profile *api.CustomizedProfile) (string, error) {
+func (s *Server) generateRSSFromMemoList(ctx context.Context, memoList []*store.MemoMessage, baseURL string, profile *api.CustomizedProfile) (string, error) {
 	feed := &feeds.Feed{
 		Title:       profile.Name,
 		Link:        &feeds.Link{Href: baseURL},
@@ -98,15 +99,15 @@ func (s *Server) generateRSSFromMemoList(ctx context.Context, memoList []*api.Me
 			Created:     time.Unix(memo.CreatedTs, 0),
 			Enclosure:   &feeds.Enclosure{Url: baseURL + "/m/" + strconv.Itoa(memo.ID) + "/image"},
 		}
-		resourceList, err := s.Store.FindResourceList(ctx, &api.ResourceFind{
+		if len(memo.ResourceIDList) > 0 {
-			MemoID: &memo.ID,
+			resourceID := memo.ResourceIDList[0]
+			resource, err := s.Store.FindResource(ctx, &api.ResourceFind{
+				ID: &resourceID,
 			})
 			if err != nil {
 				return "", err
 			}
-		if len(resourceList) > 0 {
 			enclosure := feeds.Enclosure{}
-			resource := resourceList[0]
 			if resource.ExternalLink != "" {
 				enclosure.Url = resource.ExternalLink
 			} else {

server/tag.go

@@ -10,6 +10,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/usememos/memos/api"
 	"github.com/usememos/memos/common"
+	"github.com/usememos/memos/store"
 	"golang.org/x/exp/slices"
 
 	"github.com/labstack/echo/v4"
@@ -71,14 +72,14 @@ func (s *Server) registerTagRoutes(g *echo.Group) {
 			return echo.NewHTTPError(http.StatusBadRequest, "Missing user session")
 		}
 		contentSearch := "#"
-		normalRowStatus := api.Normal
+		normalRowStatus := store.Normal
-		memoFind := api.MemoFind{
+		memoFind := &store.FindMemoMessage{
 			CreatorID:     &userID,
 			ContentSearch: &contentSearch,
 			RowStatus:     &normalRowStatus,
 		}
 
-		memoList, err := s.Store.FindMemoList(ctx, &memoFind)
+		memoMessageList, err := s.Store.ListMemos(ctx, memoFind)
 		if err != nil {
 			return echo.NewHTTPError(http.StatusInternalServerError, "Failed to find memo list").SetInternal(err)
 		}
@@ -96,7 +97,7 @@ func (s *Server) registerTagRoutes(g *echo.Group) {
 		}
 
 		tagMapSet := make(map[string]bool)
-		for _, memo := range memoList {
+		for _, memo := range memoMessageList {
 			for _, tag := range findTagListFromMemoContent(memo.Content) {
 				if !slices.Contains(tagNameList, tag) {
 					tagMapSet[tag] = true

store/common.go

@@ -0,0 +1,21 @@
+package store
+
+// RowStatus is the status for a row.
+type RowStatus string
+
+const (
+	// Normal is the status for a normal row.
+	Normal RowStatus = "NORMAL"
+	// Archived is the status for an archived row.
+	Archived RowStatus = "ARCHIVED"
+)
+
+func (r RowStatus) String() string {
+	switch r {
+	case Normal:
+		return "NORMAL"
+	case Archived:
+		return "ARCHIVED"
+	}
+	return ""
+}

store/memo.go

@@ -4,300 +4,221 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
+	"strconv"
 	"strings"
 
-	"github.com/usememos/memos/api"
 	"github.com/usememos/memos/common"
 )
 
-// memoRaw is the store model for an Memo.
+// Visibility is the type of a visibility.
-// Fields have exactly the same meanings as Memo.
+type Visibility string
-type memoRaw struct {
+
+const (
+	// Public is the PUBLIC visibility.
+	Public Visibility = "PUBLIC"
+	// Protected is the PROTECTED visibility.
+	Protected Visibility = "PROTECTED"
+	// Private is the PRIVATE visibility.
+	Private Visibility = "PRIVATE"
+)
+
+func (v Visibility) String() string {
+	switch v {
+	case Public:
+		return "PUBLIC"
+	case Protected:
+		return "PROTECTED"
+	case Private:
+		return "PRIVATE"
+	}
+	return "PRIVATE"
+}
+
+type MemoMessage struct {
 	ID int
 
 	// Standard fields
-	RowStatus api.RowStatus
+	RowStatus RowStatus
 	CreatorID int
 	CreatedTs int64
 	UpdatedTs int64
 
 	// Domain specific fields
 	Content    string
-	Visibility api.Visibility
+	Visibility Visibility
+
+	// Composed fields
 	Pinned         bool
+	ResourceIDList []int
+	RelationList   []*MemoRelationMessage
 }
 
-// toMemo creates an instance of Memo based on the memoRaw.
+type FindMemoMessage struct {
-// This is intended to be called when we need to compose an Memo relationship.
+	ID *int
-func (raw *memoRaw) toMemo() *api.Memo {
-	return &api.Memo{
-		ID: raw.ID,
 
 	// Standard fields
-		RowStatus: raw.RowStatus,
+	RowStatus *RowStatus
-		CreatorID: raw.CreatorID,
+	CreatorID *int
-		CreatedTs: raw.CreatedTs,
-		UpdatedTs: raw.UpdatedTs,
 
 	// Domain specific fields
-		Content:      raw.Content,
+	Pinned         *bool
-		Visibility:   raw.Visibility,
+	ContentSearch  *string
-		Pinned:       raw.Pinned,
+	VisibilityList []Visibility
-		ResourceList: []*api.Resource{},
+
-		RelationList: []*api.MemoRelation{},
+	// Pagination
-	}
+	Limit  *int
+	Offset *int
 }
 
-func (s *Store) ComposeMemo(ctx context.Context, memo *api.Memo) (*api.Memo, error) {
+type UpdateMemoMessage struct {
-	if err := s.ComposeMemoCreator(ctx, memo); err != nil {
+	ID         int
-		return nil, err
+	CreatedTs  *int64
-	}
+	UpdatedTs  *int64
-	if err := s.ComposeMemoResourceList(ctx, memo); err != nil {
+	RowStatus  *RowStatus
-		return nil, err
+	Content    *string
-	}
+	Visibility *Visibility
-	if err := s.ComposeMemoRelationList(ctx, memo); err != nil {
-		return nil, err
 }
 
-	return memo, nil
+type DeleteMemoMessage struct {
+	ID int
 }
 
-func (s *Store) CreateMemo(ctx context.Context, create *api.MemoCreate) (*api.Memo, error) {
+func (s *Store) CreateMemo(ctx context.Context, create *MemoMessage) (*MemoMessage, error) {
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {
 		return nil, FormatError(err)
 	}
 	defer tx.Rollback()
 
-	memoRaw, err := createMemoRaw(ctx, tx, create)
+	query := `
-	if err != nil {
+		INSERT INTO memo (
-		return nil, err
+			creator_id,
+			created_ts,
+			content,
+			visibility
+		)
+		VALUES (?, ?, ?, ?)
+		RETURNING id, created_ts, updated_ts, row_status
+	`
+	if err := tx.QueryRowContext(
+		ctx,
+		query,
+		create.CreatorID,
+		create.CreatedTs,
+		create.Content,
+		create.Visibility,
+	).Scan(
+		&create.ID,
+		&create.CreatedTs,
+		&create.UpdatedTs,
+		&create.RowStatus,
+	); err != nil {
+		return nil, FormatError(err)
 	}
-
 	if err := tx.Commit(); err != nil {
 		return nil, FormatError(err)
 	}
-
+	memoMessage := create
-	s.memoCache.Store(memoRaw.ID, memoRaw)
+	return memoMessage, nil
-	memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
-	if err != nil {
-		return nil, err
 }
 
-	return memo, nil
+func (s *Store) ListMemos(ctx context.Context, find *FindMemoMessage) ([]*MemoMessage, error) {
-}
-
-func (s *Store) PatchMemo(ctx context.Context, patch *api.MemoPatch) (*api.Memo, error) {
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {
 		return nil, FormatError(err)
 	}
 	defer tx.Rollback()
 
-	memoRaw, err := patchMemoRaw(ctx, tx, patch)
+	list, err := listMemos(ctx, tx, find)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := tx.Commit(); err != nil {
-		return nil, FormatError(err)
-	}
-
-	s.memoCache.Store(memoRaw.ID, memoRaw)
-	memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
-	if err != nil {
-		return nil, err
-	}
-
-	return memo, nil
-}
-
-func (s *Store) FindMemoList(ctx context.Context, find *api.MemoFind) ([]*api.Memo, error) {
-	tx, err := s.db.BeginTx(ctx, nil)
-	if err != nil {
-		return nil, FormatError(err)
-	}
-	defer tx.Rollback()
-
-	memoRawList, err := findMemoRawList(ctx, tx, find)
-	if err != nil {
-		return nil, err
-	}
-
-	list := []*api.Memo{}
-	for _, raw := range memoRawList {
-		memo, err := s.ComposeMemo(ctx, raw.toMemo())
-		if err != nil {
-			return nil, err
-		}
-
-		list = append(list, memo)
-	}
-
 	return list, nil
 }
 
-func (s *Store) FindMemo(ctx context.Context, find *api.MemoFind) (*api.Memo, error) {
+func (s *Store) GetMemo(ctx context.Context, find *FindMemoMessage) (*MemoMessage, error) {
-	if find.ID != nil {
-		if memo, ok := s.memoCache.Load(*find.ID); ok {
-			memoRaw := memo.(*memoRaw)
-			memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
-			if err != nil {
-				return nil, err
-			}
-			return memo, nil
-		}
-	}
-
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {
 		return nil, FormatError(err)
 	}
 	defer tx.Rollback()
 
-	list, err := findMemoRawList(ctx, tx, find)
+	list, err := listMemos(ctx, tx, find)
 	if err != nil {
 		return nil, err
 	}
-
 	if len(list) == 0 {
-		return nil, &common.Error{Code: common.NotFound, Err: fmt.Errorf("not found")}
+		return nil, &common.Error{Code: common.NotFound, Err: fmt.Errorf("memo not found")}
 	}
 
-	memoRaw := list[0]
+	memoMessage := list[0]
-	s.memoCache.Store(memoRaw.ID, memoRaw)
+	return memoMessage, nil
-	memo, err := s.ComposeMemo(ctx, memoRaw.toMemo())
-	if err != nil {
-		return nil, err
 }
 
-	return memo, nil
+func (s *Store) UpdateMemo(ctx context.Context, update *UpdateMemoMessage) error {
-}
-
-func (s *Store) DeleteMemo(ctx context.Context, delete *api.MemoDelete) error {
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {
-		return FormatError(err)
-	}
-	defer tx.Rollback()
-
-	if err := deleteMemo(ctx, tx, delete); err != nil {
-		return FormatError(err)
-	}
-	if err := s.vacuumImpl(ctx, tx); err != nil {
 		return err
 	}
+	defer tx.Rollback()
 
-	if err := tx.Commit(); err != nil {
-		return FormatError(err)
-	}
-
-	s.memoCache.Delete(delete.ID)
-	return nil
-}
-
-func createMemoRaw(ctx context.Context, tx *sql.Tx, create *api.MemoCreate) (*memoRaw, error) {
-	set := []string{"creator_id", "content", "visibility"}
-	args := []any{create.CreatorID, create.Content, create.Visibility}
-	placeholder := []string{"?", "?", "?"}
-
-	if v := create.CreatedTs; v != nil {
-		set, args, placeholder = append(set, "created_ts"), append(args, *v), append(placeholder, "?")
-	}
-
-	query := `
-		INSERT INTO memo (
-			` + strings.Join(set, ", ") + `
-		)
-		VALUES (` + strings.Join(placeholder, ",") + `)
-		RETURNING id, creator_id, created_ts, updated_ts, row_status, content, visibility
-	`
-	var memoRaw memoRaw
-	if err := tx.QueryRowContext(ctx, query, args...).Scan(
-		&memoRaw.ID,
-		&memoRaw.CreatorID,
-		&memoRaw.CreatedTs,
-		&memoRaw.UpdatedTs,
-		&memoRaw.RowStatus,
-		&memoRaw.Content,
-		&memoRaw.Visibility,
-	); err != nil {
-		return nil, FormatError(err)
-	}
-
-	return &memoRaw, nil
-}
-
-func patchMemoRaw(ctx context.Context, tx *sql.Tx, patch *api.MemoPatch) (*memoRaw, error) {
 	set, args := []string{}, []any{}
-
+	if v := update.CreatedTs; v != nil {
-	if v := patch.CreatedTs; v != nil {
 		set, args = append(set, "created_ts = ?"), append(args, *v)
 	}
-	if v := patch.UpdatedTs; v != nil {
+	if v := update.UpdatedTs; v != nil {
 		set, args = append(set, "updated_ts = ?"), append(args, *v)
 	}
-	if v := patch.RowStatus; v != nil {
+	if v := update.Content; v != nil {
-		set, args = append(set, "row_status = ?"), append(args, *v)
-	}
-	if v := patch.Content; v != nil {
 		set, args = append(set, "content = ?"), append(args, *v)
 	}
-	if v := patch.Visibility; v != nil {
+	if v := update.Visibility; v != nil {
 		set, args = append(set, "visibility = ?"), append(args, *v)
 	}
-
+	args = append(args, update.ID)
-	args = append(args, patch.ID)
 
 	query := `
 		UPDATE memo
 		SET ` + strings.Join(set, ", ") + `
 		WHERE id = ?
-		RETURNING id, creator_id, created_ts, updated_ts, row_status, content, visibility
 	`
-	var memoRaw memoRaw
+	if _, err := tx.ExecContext(ctx, query, args...); err != nil {
-	if err := tx.QueryRowContext(ctx, query, args...).Scan(
+		return err
-		&memoRaw.ID,
+	}
-		&memoRaw.CreatorID,
+	err = tx.Commit()
-		&memoRaw.CreatedTs,
+	return err
-		&memoRaw.UpdatedTs,
-		&memoRaw.RowStatus,
-		&memoRaw.Content,
-		&memoRaw.Visibility,
-	); err != nil {
-		return nil, FormatError(err)
 }
 
-	pinnedQuery := `
+func (s *Store) DeleteMemo(ctx context.Context, delete *DeleteMemoMessage) error {
-		SELECT
+	tx, err := s.db.BeginTx(ctx, nil)
-			pinned
-		FROM memo_organizer
-		WHERE memo_id = ? AND user_id = ?
-	`
-	row, err := tx.QueryContext(ctx, pinnedQuery, patch.ID, memoRaw.CreatorID)
 	if err != nil {
-		return nil, FormatError(err)
+		return FormatError(err)
 	}
-	defer row.Close()
+	defer tx.Rollback()
 
-	if !row.Next() {
+	where, args := []string{"id = ?"}, []any{delete.ID}
-		memoRaw.Pinned = false
+	stmt := `DELETE FROM memo WHERE ` + strings.Join(where, " AND ")
-	} else {
+	result, err := tx.ExecContext(ctx, stmt, args...)
-		if err := row.Scan(
+	if err != nil {
-			&memoRaw.Pinned,
+		return FormatError(err)
-		); err != nil {
-			return nil, FormatError(err)
-		}
 	}
 
-	if err := row.Err(); err != nil {
+	rows, err := result.RowsAffected()
-		return nil, err
+	if err != nil {
+		return err
+	}
+	if rows == 0 {
+		return &common.Error{Code: common.NotFound, Err: fmt.Errorf("idp not found")}
+	}
+	if err := s.vacuumImpl(ctx, tx); err != nil {
+		return err
+	}
+	err = tx.Commit()
+	return err
 }
 
-	return &memoRaw, nil
+func listMemos(ctx context.Context, tx *sql.Tx, find *FindMemoMessage) ([]*MemoMessage, error) {
-}
-
-func findMemoRawList(ctx context.Context, tx *sql.Tx, find *api.MemoFind) ([]*memoRaw, error) {
 	where, args := []string{"1 = 1"}, []any{}
 
 	if v := find.ID; v != nil {
@@ -326,17 +247,33 @@ func findMemoRawList(ctx context.Context, tx *sql.Tx, find *api.MemoFind) ([]*me
 
 	query := `
 	SELECT
-			memo.id,
+		memo.id AS id,
-			memo.creator_id,
+		memo.creator_id AS creator_id,
-			memo.created_ts,
+		memo.created_ts AS created_ts,
-			memo.updated_ts,
+		memo.updated_ts AS updated_ts,
-			memo.row_status,
+		memo.row_status AS row_status,
-			memo.content,
+		memo.content AS content,
-			memo.visibility,
+		memo.visibility AS visibility,
-			IFNULL(memo_organizer.pinned, 0) AS pinned
+		CASE WHEN memo_organizer.pinned = 1 THEN 1 ELSE 0 END AS pinned,
-		FROM memo
+		GROUP_CONCAT(memo_resource.resource_id) AS resource_id_list,
-		LEFT JOIN memo_organizer ON memo_organizer.memo_id = memo.id AND memo_organizer.user_id = memo.creator_id
+		(
+				SELECT
+						GROUP_CONCAT(related_memo_id || ':' || type)
+				FROM
+						memo_relation
+				WHERE
+						memo_relation.memo_id = memo.id
+				GROUP BY
+						memo_relation.memo_id
+		) AS relation_list
+	FROM
+		memo
+	LEFT JOIN
+		memo_organizer ON memo.id = memo_organizer.memo_id
+	LEFT JOIN
+		memo_resource ON memo.id = memo_resource.memo_id
 	WHERE ` + strings.Join(where, " AND ") + `
+	GROUP BY memo.id
 	ORDER BY pinned DESC, memo.created_ts DESC
 	`
 	if find.Limit != nil {
@@ -352,51 +289,64 @@ func findMemoRawList(ctx context.Context, tx *sql.Tx, find *api.MemoFind) ([]*me
 	}
 	defer rows.Close()
 
-	memoRawList := make([]*memoRaw, 0)
+	memoMessageList := make([]*MemoMessage, 0)
 	for rows.Next() {
-		var memoRaw memoRaw
+		var memoMessage MemoMessage
-		var pinned sql.NullBool
+		var memoResourceIDList sql.NullString
+		var memoRelationList sql.NullString
 		if err := rows.Scan(
-			&memoRaw.ID,
+			&memoMessage.ID,
-			&memoRaw.CreatorID,
+			&memoMessage.CreatorID,
-			&memoRaw.CreatedTs,
+			&memoMessage.CreatedTs,
-			&memoRaw.UpdatedTs,
+			&memoMessage.UpdatedTs,
-			&memoRaw.RowStatus,
+			&memoMessage.RowStatus,
-			&memoRaw.Content,
+			&memoMessage.Content,
-			&memoRaw.Visibility,
+			&memoMessage.Visibility,
-			&pinned,
+			&memoMessage.Pinned,
+			&memoResourceIDList,
+			&memoRelationList,
 		); err != nil {
 			return nil, FormatError(err)
 		}
 
-		if pinned.Valid {
+		if memoResourceIDList.Valid {
-			memoRaw.Pinned = pinned.Bool
+			idStringList := strings.Split(memoResourceIDList.String, ",")
+			memoMessage.ResourceIDList = make([]int, 0, len(idStringList))
+			for _, idString := range idStringList {
+				id, err := strconv.Atoi(idString)
+				if err != nil {
+					return nil, FormatError(err)
 				}
-		memoRawList = append(memoRawList, &memoRaw)
+				memoMessage.ResourceIDList = append(memoMessage.ResourceIDList, id)
+			}
+		}
+		if memoRelationList.Valid {
+			memoMessage.RelationList = make([]*MemoRelationMessage, 0)
+			relatedMemoTypeList := strings.Split(memoRelationList.String, ",")
+			for _, relatedMemoType := range relatedMemoTypeList {
+				relatedMemoTypeList := strings.Split(relatedMemoType, ":")
+				if len(relatedMemoTypeList) != 2 {
+					return nil, &common.Error{Code: common.Invalid, Err: fmt.Errorf("invalid relation format")}
+				}
+				relatedMemoID, err := strconv.Atoi(relatedMemoTypeList[0])
+				if err != nil {
+					return nil, FormatError(err)
+				}
+				memoMessage.RelationList = append(memoMessage.RelationList, &MemoRelationMessage{
+					MemoID:        memoMessage.ID,
+					RelatedMemoID: relatedMemoID,
+					Type:          MemoRelationType(relatedMemoTypeList[1]),
+				})
+			}
+		}
+		memoMessageList = append(memoMessageList, &memoMessage)
 	}
 
 	if err := rows.Err(); err != nil {
 		return nil, FormatError(err)
 	}
 
-	return memoRawList, nil
+	return memoMessageList, nil
-}
-
-func deleteMemo(ctx context.Context, tx *sql.Tx, delete *api.MemoDelete) error {
-	where, args := []string{"id = ?"}, []any{delete.ID}
-
-	stmt := `DELETE FROM memo WHERE ` + strings.Join(where, " AND ")
-	result, err := tx.ExecContext(ctx, stmt, args...)
-	if err != nil {
-		return FormatError(err)
-	}
-
-	rows, _ := result.RowsAffected()
-	if rows == 0 {
-		return &common.Error{Code: common.NotFound, Err: fmt.Errorf("memo not found")}
-	}
-
-	return nil
 }
 
 func vacuumMemo(ctx context.Context, tx *sql.Tx) error {

store/memo_relation.go

@@ -6,30 +6,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/usememos/memos/api"
 	"github.com/usememos/memos/common"
 )
 
-func (s *Store) ComposeMemoRelationList(ctx context.Context, memo *api.Memo) error {
-	memoRelationList, err := s.ListMemoRelations(ctx, &FindMemoRelationMessage{
-		MemoID: &memo.ID,
-	})
-	if err != nil {
-		return err
-	}
-
-	memo.RelationList = []*api.MemoRelation{}
-	for _, memoRelation := range memoRelationList {
-		memo.RelationList = append(memo.RelationList, &api.MemoRelation{
-			MemoID:        memoRelation.MemoID,
-			RelatedMemoID: memoRelation.RelatedMemoID,
-			Type:          api.MemoRelationType(memoRelation.Type),
-		})
-	}
-
-	return nil
-}
-
 type MemoRelationType string
 
 const (

store/resource.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
-	"sort"
 	"strings"
 
 	"github.com/usememos/memos/api"
@@ -53,40 +52,6 @@ func (raw *resourceRaw) toResource() *api.Resource {
 	}
 }
 
-func (s *Store) ComposeMemoResourceList(ctx context.Context, memo *api.Memo) error {
-	resourceList, err := s.FindResourceList(ctx, &api.ResourceFind{
-		MemoID: &memo.ID,
-	})
-	if err != nil {
-		return err
-	}
-
-	for _, resource := range resourceList {
-		memoResource, err := s.FindMemoResource(ctx, &api.MemoResourceFind{
-			MemoID:     &memo.ID,
-			ResourceID: &resource.ID,
-		})
-		if err != nil {
-			return err
-		}
-
-		resource.CreatedTs = memoResource.CreatedTs
-		resource.UpdatedTs = memoResource.UpdatedTs
-	}
-
-	sort.Slice(resourceList, func(i, j int) bool {
-		if resourceList[i].CreatedTs != resourceList[j].CreatedTs {
-			return resourceList[i].CreatedTs < resourceList[j].CreatedTs
-		}
-
-		return resourceList[i].ID < resourceList[j].ID
-	})
-
-	memo.ResourceList = resourceList
-
-	return nil
-}
-
 func (s *Store) CreateResource(ctx context.Context, create *api.ResourceCreate) (*api.Resource, error) {
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {

store/store.go

@@ -15,7 +15,6 @@ type Store struct {
 	systemSettingCache sync.Map // map[string]*systemSettingRaw
 	userCache          sync.Map // map[int]*userRaw
 	userSettingCache   sync.Map // map[string]*userSettingRaw
-	memoCache          sync.Map // map[int]*memoRaw
 	shortcutCache      sync.Map // map[int]*shortcutRaw
 	idpCache           sync.Map // map[int]*identityProviderMessage
 }

store/user.go

@@ -11,36 +11,22 @@ import (
 )
 
 func (s *Store) SeedDataForNewUser(ctx context.Context, user *api.User) error {
-	tx, err := s.db.BeginTx(ctx, nil)
-	if err != nil {
-		return FormatError(err)
-	}
-	defer tx.Rollback()
-
 	// Create a memo for the user.
-	_, err = createMemoRaw(ctx, tx, &api.MemoCreate{
+	_, err := s.CreateMemo(ctx, &MemoMessage{
 		CreatorID:  user.ID,
 		Content:    "#inbox Welcome to Memos!",
-		Visibility: api.Private,
+		Visibility: Private,
 	})
 	if err != nil {
 		return err
 	}
-	_, err = upsertTag(ctx, tx, &api.TagUpsert{
+	_, err = s.UpsertTag(ctx, &api.TagUpsert{
 		CreatorID: user.ID,
 		Name:      "inbox",
 	})
-	if err != nil {
 	return err
 }
 
-	if err := tx.Commit(); err != nil {
-		return FormatError(err)
-	}
-
-	return nil
-}
-
 // userRaw is the store model for an User.
 // Fields have exactly the same meanings as User.
 type userRaw struct {
@@ -79,22 +65,6 @@ func (raw *userRaw) toUser() *api.User {
 	}
 }
 
-func (s *Store) ComposeMemoCreator(ctx context.Context, memo *api.Memo) error {
-	user, err := s.FindUser(ctx, &api.UserFind{
-		ID: &memo.CreatorID,
-	})
-	if err != nil {
-		return err
-	}
-
-	if user.Nickname != "" {
-		memo.CreatorName = user.Nickname
-	} else {
-		memo.CreatorName = user.Username
-	}
-	return nil
-}
-
 func (s *Store) CreateUser(ctx context.Context, create *api.UserCreate) (*api.User, error) {
 	tx, err := s.db.BeginTx(ctx, nil)
 	if err != nil {

test/server/memo_relation_test.go

@@ -28,12 +28,12 @@ func TestMemoRelationServer(t *testing.T) {
 	memoList, err := s.getMemoList()
 	require.NoError(t, err)
 	require.Len(t, memoList, 1)
-	memo, err := s.postMemoCreate(&api.MemoCreate{
+	memo, err := s.postMemoCreate(&api.CreateMemoRequest{
 		Content: "test memo",
 	})
 	require.NoError(t, err)
 	require.Equal(t, "test memo", memo.Content)
-	memo2, err := s.postMemoCreate(&api.MemoCreate{
+	memo2, err := s.postMemoCreate(&api.CreateMemoRequest{
 		Content: "test memo2",
 		RelationList: []*api.MemoRelationUpsert{
 			{

test/server/memo_test.go

@@ -28,7 +28,7 @@ func TestMemoServer(t *testing.T) {
 	memoList, err := s.getMemoList()
 	require.NoError(t, err)
 	require.Len(t, memoList, 1)
-	memo, err := s.postMemoCreate(&api.MemoCreate{
+	memo, err := s.postMemoCreate(&api.CreateMemoRequest{
 		Content: "test memo",
 	})
 	require.NoError(t, err)
@@ -37,7 +37,7 @@ func TestMemoServer(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, memoList, 2)
 	updatedContent := "updated memo"
-	memo, err = s.patchMemo(&api.MemoPatch{
+	memo, err = s.patchMemo(&api.PatchMemoRequest{
 		ID:      memo.ID,
 		Content: &updatedContent,
 	})
@@ -50,23 +50,21 @@ func TestMemoServer(t *testing.T) {
 		Pinned: true,
 	})
 	require.NoError(t, err)
-	memo, err = s.patchMemo(&api.MemoPatch{
+	memo, err = s.patchMemo(&api.PatchMemoRequest{
 		ID:      memo.ID,
 		Content: &updatedContent,
 	})
 	require.NoError(t, err)
 	require.Equal(t, updatedContent, memo.Content)
 	require.Equal(t, true, memo.Pinned)
-	err = s.deleteMemo(&api.MemoDelete{
+	err = s.deleteMemo(memo.ID)
-		ID: memo.ID,
-	})
 	require.NoError(t, err)
 	memoList, err = s.getMemoList()
 	require.NoError(t, err)
 	require.Len(t, memoList, 1)
 }
 
-func (s *TestingServer) getMemo(memoID int) (*api.Memo, error) {
+func (s *TestingServer) getMemo(memoID int) (*api.MemoResponse, error) {
 	body, err := s.get(fmt.Sprintf("/api/memo/%d", memoID), nil)
 	if err != nil {
 		return nil, err
@@ -79,7 +77,7 @@ func (s *TestingServer) getMemo(memoID int) (*api.Memo, error) {
 	}
 
 	type MemoCreateResponse struct {
-		Data *api.Memo `json:"data"`
+		Data *api.MemoResponse `json:"data"`
 	}
 	res := new(MemoCreateResponse)
 	if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@@ -88,7 +86,7 @@ func (s *TestingServer) getMemo(memoID int) (*api.Memo, error) {
 	return res.Data, nil
 }
 
-func (s *TestingServer) getMemoList() ([]*api.Memo, error) {
+func (s *TestingServer) getMemoList() ([]*api.MemoResponse, error) {
 	body, err := s.get("/api/memo", nil)
 	if err != nil {
 		return nil, err
@@ -101,7 +99,7 @@ func (s *TestingServer) getMemoList() ([]*api.Memo, error) {
 	}
 
 	type MemoCreateResponse struct {
-		Data []*api.Memo `json:"data"`
+		Data []*api.MemoResponse `json:"data"`
 	}
 	res := new(MemoCreateResponse)
 	if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@@ -110,7 +108,7 @@ func (s *TestingServer) getMemoList() ([]*api.Memo, error) {
 	return res.Data, nil
 }
 
-func (s *TestingServer) postMemoCreate(memoCreate *api.MemoCreate) (*api.Memo, error) {
+func (s *TestingServer) postMemoCreate(memoCreate *api.CreateMemoRequest) (*api.MemoResponse, error) {
 	rawData, err := json.Marshal(&memoCreate)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to marshal memo create")
@@ -128,7 +126,7 @@ func (s *TestingServer) postMemoCreate(memoCreate *api.MemoCreate) (*api.Memo, e
 	}
 
 	type MemoCreateResponse struct {
-		Data *api.Memo `json:"data"`
+		Data *api.MemoResponse `json:"data"`
 	}
 	res := new(MemoCreateResponse)
 	if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@@ -137,7 +135,7 @@ func (s *TestingServer) postMemoCreate(memoCreate *api.MemoCreate) (*api.Memo, e
 	return res.Data, nil
 }
 
-func (s *TestingServer) patchMemo(memoPatch *api.MemoPatch) (*api.Memo, error) {
+func (s *TestingServer) patchMemo(memoPatch *api.PatchMemoRequest) (*api.MemoResponse, error) {
 	rawData, err := json.Marshal(&memoPatch)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to marshal memo patch")
@@ -155,7 +153,7 @@ func (s *TestingServer) patchMemo(memoPatch *api.MemoPatch) (*api.Memo, error) {
 	}
 
 	type MemoPatchResponse struct {
-		Data *api.Memo `json:"data"`
+		Data *api.MemoResponse `json:"data"`
 	}
 	res := new(MemoPatchResponse)
 	if err = json.Unmarshal(buf.Bytes(), res); err != nil {
@@ -164,12 +162,12 @@ func (s *TestingServer) patchMemo(memoPatch *api.MemoPatch) (*api.Memo, error) {
 	return res.Data, nil
 }
 
-func (s *TestingServer) deleteMemo(memoDelete *api.MemoDelete) error {
+func (s *TestingServer) deleteMemo(memoID int) error {
-	_, err := s.delete(fmt.Sprintf("/api/memo/%d", memoDelete.ID), nil)
+	_, err := s.delete(fmt.Sprintf("/api/memo/%d", memoID), nil)
 	return err
 }
 
-func (s *TestingServer) postMemosOrganizer(memosOrganizer *api.MemoOrganizerUpsert) (*api.Memo, error) {
+func (s *TestingServer) postMemosOrganizer(memosOrganizer *api.MemoOrganizerUpsert) (*api.MemoResponse, error) {
 	rawData, err := json.Marshal(&memosOrganizer)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to marshal memos organizer")
@@ -187,7 +185,7 @@ func (s *TestingServer) postMemosOrganizer(memosOrganizer *api.MemoOrganizerUpse
 	}
 
 	type MemoOrganizerResponse struct {
-		Data *api.Memo `json:"data"`
+		Data *api.MemoResponse `json:"data"`
 	}
 	res := new(MemoOrganizerResponse)
 	if err = json.Unmarshal(buf.Bytes(), res); err != nil {

test/store/memo_relation_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	"github.com/usememos/memos/api"
 	"github.com/usememos/memos/store"
 )
 
@@ -14,22 +13,22 @@ func TestMemoRelationStore(t *testing.T) {
 	ts := NewTestingStore(ctx, t)
 	user, err := createTestingHostUser(ctx, ts)
 	require.NoError(t, err)
-	memoCreate := &api.MemoCreate{
+	memoCreate := &store.MemoMessage{
 		CreatorID:  user.ID,
 		Content:    "test_content",
-		Visibility: api.Public,
+		Visibility: store.Public,
 	}
 	memo, err := ts.CreateMemo(ctx, memoCreate)
 	require.NoError(t, err)
 	require.Equal(t, memoCreate.Content, memo.Content)
-	memoCreate = &api.MemoCreate{
+	memo2Create := &store.MemoMessage{
 		CreatorID:  user.ID,
 		Content:    "test_content_2",
-		Visibility: api.Public,
+		Visibility: store.Public,
 	}
-	memo2, err := ts.CreateMemo(ctx, memoCreate)
+	memo2, err := ts.CreateMemo(ctx, memo2Create)
 	require.NoError(t, err)
-	require.Equal(t, memoCreate.Content, memo2.Content)
+	require.Equal(t, memo2Create.Content, memo2.Content)
 	memoRelationMessage := &store.MemoRelationMessage{
 		MemoID:        memo.ID,
 		RelatedMemoID: memo2.ID,
@@ -45,7 +44,7 @@ func TestMemoRelationStore(t *testing.T) {
 	require.Equal(t, memo2.ID, memoRelation[0].RelatedMemoID)
 	require.Equal(t, memo.ID, memoRelation[0].MemoID)
 	require.Equal(t, store.MemoRelationReference, memoRelation[0].Type)
-	err = ts.DeleteMemo(ctx, &api.MemoDelete{
+	err = ts.DeleteMemo(ctx, &store.DeleteMemoMessage{
 		ID: memo2.ID,
 	})
 	require.NoError(t, err)

test/store/memo_test.go

@@ -5,37 +5,40 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	"github.com/usememos/memos/api"
+	"github.com/usememos/memos/store"
 )
 
 func TestMemoStore(t *testing.T) {
 	ctx := context.Background()
-	store := NewTestingStore(ctx, t)
+	ts := NewTestingStore(ctx, t)
-	user, err := createTestingHostUser(ctx, store)
+	user, err := createTestingHostUser(ctx, ts)
 	require.NoError(t, err)
-	memoCreate := &api.MemoCreate{
+	memoCreate := &store.MemoMessage{
 		CreatorID:  user.ID,
 		Content:    "test_content",
-		Visibility: api.Public,
+		Visibility: store.Public,
 	}
-	memo, err := store.CreateMemo(ctx, memoCreate)
+	memo, err := ts.CreateMemo(ctx, memoCreate)
 	require.NoError(t, err)
 	require.Equal(t, memoCreate.Content, memo.Content)
 	memoPatchContent := "test_content_2"
-	memoPatch := &api.MemoPatch{
+	memoPatch := &store.UpdateMemoMessage{
 		ID:      memo.ID,
 		Content: &memoPatchContent,
 	}
-	memo, err = store.PatchMemo(ctx, memoPatch)
+	err = ts.UpdateMemo(ctx, memoPatch)
 	require.NoError(t, err)
-	require.Equal(t, memoPatchContent, memo.Content)
+	memo, err = ts.GetMemo(ctx, &store.FindMemoMessage{
-	memoList, err := store.FindMemoList(ctx, &api.MemoFind{
+		ID: &memo.ID,
+	})
+	require.NoError(t, err)
+	memoList, err := ts.ListMemos(ctx, &store.FindMemoMessage{
 		CreatorID: &user.ID,
 	})
 	require.NoError(t, err)
 	require.Equal(t, 2, len(memoList))
 	require.Equal(t, memo, memoList[1])
-	err = store.DeleteMemo(ctx, &api.MemoDelete{
+	err = ts.DeleteMemo(ctx, &store.DeleteMemoMessage{
 		ID: memo.ID,
 	})
 	require.NoError(t, err)