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.

fix: delete comment subtree when a memo is deleted (#6424)

Hussnain Ahmad5d1649bec693
diff --git a/proto/api/v1/memo_service.proto b/proto/api/v1/memo_service.proto
index abe9f7f04..cb48a98be 100644
--- a/proto/api/v1/memo_service.proto
+++ b/proto/api/v1/memo_service.proto
@@ -44,8 +44,9 @@ service MemoService {
};
option (google.api.method_signature) = "memo,update_mask";
}
- // DeleteMemo deletes only the named memo and its owned resources. It removes
- // incident relations but never deletes another memo.
+ // DeleteMemo deletes the named memo and its comment subtree, including nested
+ // replies and their owned resources. It removes incident relations for all
+ // deleted memos.
rpc DeleteMemo(DeleteMemoRequest) returns (google.protobuf.Empty) {
option (google.api.http) = {delete: "/api/v1/{name=memos/*}"};
option (google.api.method_signature) = "name";
diff --git a/proto/gen/api/v1/apiv1connect/memo_service.connect.go b/proto/gen/api/v1/apiv1connect/memo_service.connect.go
index e21259db3..e145484a6 100644
--- a/proto/gen/api/v1/apiv1connect/memo_service.connect.go
+++ b/proto/gen/api/v1/apiv1connect/memo_service.connect.go
@@ -104,8 +104,9 @@ type MemoServiceClient interface {
GetMemo(context.Context, *connect.Request[v1.GetMemoRequest]) (*connect.Response[v1.Memo], error)
// UpdateMemo updates a memo.
UpdateMemo(context.Context, *connect.Request[v1.UpdateMemoRequest]) (*connect.Response[v1.Memo], error)
- // DeleteMemo deletes only the named memo and its owned resources. It removes
- // incident relations but never deletes another memo.
+ // DeleteMemo deletes the named memo and its comment subtree, including nested
+ // replies and their owned resources. It removes incident relations for all
+ // deleted memos.
DeleteMemo(context.Context, *connect.Request[v1.DeleteMemoRequest]) (*connect.Response[emptypb.Empty], error)
// SetMemoAttachments replaces the full set of attachments on a memo with the
// provided list (not an append). Pass the complete desired set; an empty list
@@ -417,8 +418,9 @@ type MemoServiceHandler interface {
GetMemo(context.Context, *connect.Request[v1.GetMemoRequest]) (*connect.Response[v1.Memo], error)
// UpdateMemo updates a memo.
UpdateMemo(context.Context, *connect.Request[v1.UpdateMemoRequest]) (*connect.Response[v1.Memo], error)
- // DeleteMemo deletes only the named memo and its owned resources. It removes
- // incident relations but never deletes another memo.
+ // DeleteMemo deletes the named memo and its comment subtree, including nested
+ // replies and their owned resources. It removes incident relations for all
+ // deleted memos.
DeleteMemo(context.Context, *connect.Request[v1.DeleteMemoRequest]) (*connect.Response[emptypb.Empty], error)
// SetMemoAttachments replaces the full set of attachments on a memo with the
// provided list (not an append). Pass the complete desired set; an empty list
diff --git a/proto/gen/api/v1/memo_service_grpc.pb.go b/proto/gen/api/v1/memo_service_grpc.pb.go
index 27717f55d..1d4f994b6 100644
--- a/proto/gen/api/v1/memo_service_grpc.pb.go
+++ b/proto/gen/api/v1/memo_service_grpc.pb.go
@@ -57,8 +57,9 @@ type MemoServiceClient interface {
GetMemo(ctx context.Context, in *GetMemoRequest, opts ...grpc.CallOption) (*Memo, error)
// UpdateMemo updates a memo.
UpdateMemo(ctx context.Context, in *UpdateMemoRequest, opts ...grpc.CallOption) (*Memo, error)
- // DeleteMemo deletes only the named memo and its owned resources. It removes
- // incident relations but never deletes another memo.
+ // DeleteMemo deletes the named memo and its comment subtree, including nested
+ // replies and their owned resources. It removes incident relations for all
+ // deleted memos.
DeleteMemo(ctx context.Context, in *DeleteMemoRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
// SetMemoAttachments replaces the full set of attachments on a memo with the
// provided list (not an append). Pass the complete desired set; an empty list
@@ -322,8 +323,9 @@ type MemoServiceServer interface {
GetMemo(context.Context, *GetMemoRequest) (*Memo, error)
// UpdateMemo updates a memo.
UpdateMemo(context.Context, *UpdateMemoRequest) (*Memo, error)
- // DeleteMemo deletes only the named memo and its owned resources. It removes
- // incident relations but never deletes another memo.
+ // DeleteMemo deletes the named memo and its comment subtree, including nested
+ // replies and their owned resources. It removes incident relations for all
+ // deleted memos.
DeleteMemo(context.Context, *DeleteMemoRequest) (*emptypb.Empty, error)
// SetMemoAttachments replaces the full set of attachments on a memo with the
// provided list (not an append). Pass the complete desired set; an empty list
diff --git a/proto/gen/openapi.yaml b/proto/gen/openapi.yaml
index 6828e9e22..432fddf80 100644
--- a/proto/gen/openapi.yaml
+++ b/proto/gen/openapi.yaml
@@ -847,8 +847,9 @@ paths:
tags:
- MemoService
description: |-
- DeleteMemo deletes only the named memo and its owned resources. It removes
- incident relations but never deletes another memo.
+ DeleteMemo deletes the named memo and its comment subtree, including nested
+ replies and their owned resources. It removes incident relations for all
+ deleted memos.
operationId: MemoService_DeleteMemo
parameters:
- name: memo
diff --git a/server/api/v1/sse_service_test.go b/server/api/v1/sse_service_test.go
index 454c3e6dd..638718018 100644
--- a/server/api/v1/sse_service_test.go
+++ b/server/api/v1/sse_service_test.go
@@ -556,7 +556,7 @@ func TestDeleteMemoReactionPublishesMemoChanged(t *testing.T) {
mustNotReceive(t, client.events, 100*time.Millisecond)
}
-func TestDeleteMemo_DeletesOnlyRequestedMemo(t *testing.T) {
+func TestDeleteMemo_DeletesCommentSubtreeOnly(t *testing.T) {
ctx := context.Background()
svc := newIntegrationService(t)
rootAuthor, err := svc.Store.CreateUser(ctx, &store.User{
@@ -602,7 +602,7 @@ func TestDeleteMemo_DeletesOnlyRequestedMemo(t *testing.T) {
require.NoError(t, err)
storedReply, err := svc.Store.GetMemo(ctx, &store.FindMemo{UID: &replyUID})
require.NoError(t, err)
- require.NotNil(t, storedReply, "deleting a COMMENT endpoint must not cascade to the replying memo")
+ require.Nil(t, storedReply, "deleting a comment must also delete its replies")
rootUID, err := ExtractMemoUIDFromName(root.Name)
require.NoError(t, err)
storedRoot, err := svc.Store.GetMemo(ctx, &store.FindMemo{UID: &rootUID})
diff --git a/server/api/v1/test/memo_service_test.go b/server/api/v1/test/memo_service_test.go
index 4ff60b6b4..35d191e07 100644
--- a/server/api/v1/test/memo_service_test.go
+++ b/server/api/v1/test/memo_service_test.go
@@ -1263,7 +1263,7 @@ func TestMemoCommentDoesNotFollowParentVisibilityChanges(t *testing.T) {
require.Empty(t, comments.Memos, "context visibility must not expand a private comment")
}
-func TestGlobalFeedExcludesCommentsUntilContextIsDeleted(t *testing.T) {
+func TestGlobalFeedExcludesCommentsAndDeletesThemWithContext(t *testing.T) {
ctx := context.Background()
ts := NewTestService(t)
defer ts.Cleanup()
@@ -1287,14 +1287,12 @@ func TestGlobalFeedExcludesCommentsUntilContextIsDeleted(t *testing.T) {
_, err = ts.Service.DeleteMemo(ownerCtx, &apiv1.DeleteMemoRequest{Name: contextMemo.Name})
require.NoError(t, err)
- survivor, err := ts.Service.GetMemo(ownerCtx, &apiv1.GetMemoRequest{Name: comment.Name})
- require.NoError(t, err)
- require.Empty(t, survivor.GetParent())
+ _, err = ts.Service.GetMemo(ownerCtx, &apiv1.GetMemoRequest{Name: comment.Name})
+ require.Equal(t, codes.NotFound, status.Code(err))
feed, err = ts.Service.ListMemos(ownerCtx, &apiv1.ListMemosRequest{PageSize: 20})
require.NoError(t, err)
- require.Len(t, feed.Memos, 1)
- require.Equal(t, comment.Name, feed.Memos[0].Name)
+ require.Empty(t, feed.Memos)
}
// TestCreateMemoWithCustomTimestamps tests that custom timestamps can be set when creating memos and comments.
diff --git a/store/db/mysql/memo_attachment.go b/store/db/mysql/memo_attachment.go
index 92efce35f..06eebc783 100644
--- a/store/db/mysql/memo_attachment.go
+++ b/store/db/mysql/memo_attachment.go
@@ -20,6 +20,16 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation
defer func() {
_ = tx.Rollback()
}()
+ if mutation.CommentContextMemoID != nil {
+ // Deletion locks this row before scanning its replies. Lock it before
+ // any serializable snapshot reads in this transaction.
+ var contextMemoID int32
+ if err := tx.QueryRowContext(ctx, "SELECT id FROM memo WHERE id = ? FOR UPDATE", *mutation.CommentContextMemoID).Scan(&contextMemoID); errors.Is(err, sql.ErrNoRows) {
+ return store.ErrMemoMutationConflict
+ } else if err != nil {
+ return errors.Wrap(err, "failed to lock comment context memo")
+ }
+ }
if err := validateMySQLMemoRelationEndpoints(ctx, tx, mutation); err != nil {
return err
}
diff --git a/store/db/mysql/memo_delete_policy.go b/store/db/mysql/memo_delete_policy.go
index e6b6f8ee2..70c01e3c8 100644
--- a/store/db/mysql/memo_delete_policy.go
+++ b/store/db/mysql/memo_delete_policy.go
@@ -10,7 +10,9 @@ import (
)
func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoWithPolicy) (*store.DeleteMemoWithPolicyResult, error) {
- tx, err := d.db.BeginTx(ctx, nil)
+ // Later subtree and attachment reads must see writers that committed before
+ // their memo locks became available.
+ tx, err := d.db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
if err != nil {
return nil, errors.Wrap(err, "failed to begin memo delete transaction")
}
@@ -25,7 +27,7 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
var rowStatus store.RowStatus
var visibility store.Visibility
var space sql.NullInt64
- if err := tx.QueryRowContext(ctx, "SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = ?", delete.MemoID).Scan(
+ if err := tx.QueryRowContext(ctx, "SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = ? FOR UPDATE", delete.MemoID).Scan(
&creatorID, &rowStatus, &visibility, &space,
); errors.Is(err, sql.ErrNoRows) {
return nil, store.ErrMemoMutationConflict
@@ -52,7 +54,11 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
}
actorCanRead := store.MemoDeleteActorCanRead(rowStatus, visibility, spaceID, spaceExists, actorMember || actor.Admin)
- attachments, err := deleteMySQLMemoSetTx(ctx, tx, []int32{delete.MemoID})
+ deleteIDs, err := listMySQLCommentSubtreeMemoIDs(ctx, tx, delete.MemoID)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to collect comment memos")
+ }
+ attachments, err := deleteMySQLMemoSetTx(ctx, tx, deleteIDs)
if err != nil {
return nil, errors.Wrap(err, "failed to delete memo set")
}
@@ -61,3 +67,72 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
}
return &store.DeleteMemoWithPolicyResult{ActorCanRead: actorCanRead, Attachments: attachments}, nil
}
+
+// listMySQLCommentSubtreeMemoIDs returns the target memo plus every memo in
+// its comment subtree (comments, replies to comments, and so on), following
+// COMMENT relations from parent to child.
+func listMySQLCommentSubtreeMemoIDs(ctx context.Context, tx *sql.Tx, rootMemoID int32) ([]int32, error) {
+ ids := []int32{rootMemoID}
+ seen := map[int32]struct{}{rootMemoID: {}}
+ frontier := []int32{rootMemoID}
+ for len(frontier) > 0 {
+ var next []int32
+ for _, batch := range deleteUserBatches(frontier, deleteUserBatchSize) {
+ clause, args := deleteUserInClause(1, batch)
+ if err := func() error {
+ rows, err := tx.QueryContext(ctx, "SELECT memo_id FROM memo_relation WHERE type = 'COMMENT' AND related_memo_id IN "+clause, args...)
+ if err != nil {
+ return errors.Wrap(err, "failed to list comment memos")
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var childID int32
+ if err := rows.Scan(&childID); err != nil {
+ return errors.Wrap(err, "failed to read comment memo id")
+ }
+ if _, ok := seen[childID]; ok {
+ continue
+ }
+ seen[childID] = struct{}{}
+ next = append(next, childID)
+ }
+ return errors.Wrap(rows.Err(), "failed to list comment memos")
+ }(); err != nil {
+ return nil, err
+ }
+ }
+ // Comment creation takes the same memo locks before adding replies.
+ locked, err := lockMySQLCommentMemoIDs(ctx, tx, next)
+ if err != nil {
+ return nil, err
+ }
+ ids = append(ids, locked...)
+ frontier = locked
+ }
+ return ids, nil
+}
+
+func lockMySQLCommentMemoIDs(ctx context.Context, tx *sql.Tx, ids []int32) ([]int32, error) {
+ locked := make([]int32, 0, len(ids))
+ for _, batch := range deleteUserBatches(ids, deleteUserBatchSize) {
+ clause, args := deleteUserInClause(1, batch)
+ if err := func() error {
+ rows, err := tx.QueryContext(ctx, "SELECT id FROM memo WHERE id IN "+clause+" ORDER BY id FOR UPDATE", args...)
+ if err != nil {
+ return err
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var id int32
+ if err := rows.Scan(&id); err != nil {
+ return err
+ }
+ locked = append(locked, id)
+ }
+ return rows.Err()
+ }(); err != nil {
+ return nil, errors.Wrap(err, "failed to lock comment memos")
+ }
+ }
+ return locked, nil
+}
diff --git a/store/db/postgres/memo_attachment.go b/store/db/postgres/memo_attachment.go
index b100edf14..cf9e0c144 100644
--- a/store/db/postgres/memo_attachment.go
+++ b/store/db/postgres/memo_attachment.go
@@ -20,6 +20,16 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation
defer func() {
_ = tx.Rollback()
}()
+ if mutation.CommentContextMemoID != nil {
+ // Deletion locks this row before scanning its replies. Lock it before
+ // any serializable snapshot reads in this transaction.
+ var contextMemoID int32
+ if err := tx.QueryRowContext(ctx, "SELECT id FROM memo WHERE id = $1 FOR UPDATE", *mutation.CommentContextMemoID).Scan(&contextMemoID); errors.Is(err, sql.ErrNoRows) {
+ return store.ErrMemoMutationConflict
+ } else if err != nil {
+ return errors.Wrap(err, "failed to lock comment context memo")
+ }
+ }
if err := validatePostgresMemoRelationEndpoints(ctx, tx, mutation); err != nil {
return err
}
diff --git a/store/db/postgres/memo_delete_policy.go b/store/db/postgres/memo_delete_policy.go
index cac80844b..ec35d792e 100644
--- a/store/db/postgres/memo_delete_policy.go
+++ b/store/db/postgres/memo_delete_policy.go
@@ -10,7 +10,7 @@ import (
)
func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoWithPolicy) (*store.DeleteMemoWithPolicyResult, error) {
- tx, err := d.db.BeginTx(ctx, nil)
+ tx, err := d.db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
if err != nil {
return nil, errors.Wrap(err, "failed to begin memo delete transaction")
}
@@ -25,7 +25,7 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
var rowStatus store.RowStatus
var visibility store.Visibility
var memoSpace sql.NullInt64
- if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = $1`, delete.MemoID).Scan(
+ if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = $1 FOR UPDATE`, delete.MemoID).Scan(
&creatorID, &rowStatus, &visibility, &memoSpace,
); errors.Is(err, sql.ErrNoRows) {
return nil, store.ErrMemoMutationConflict
@@ -45,7 +45,11 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
}
actorCanRead := store.MemoDeleteActorCanRead(rowStatus, visibility, memoSpaceID, spaceExists, actorMember || actor.Admin)
- attachments, err := deletePostgresMemoSetTx(ctx, tx, []int32{delete.MemoID})
+ deleteIDs, err := listPostgresCommentSubtreeMemoIDs(ctx, tx, delete.MemoID)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to collect comment memos")
+ }
+ attachments, err := deletePostgresMemoSetTx(ctx, tx, deleteIDs)
if err != nil {
return nil, errors.Wrap(err, "failed to delete memo set")
}
@@ -54,3 +58,72 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
}
return &store.DeleteMemoWithPolicyResult{ActorCanRead: actorCanRead, Attachments: attachments}, nil
}
+
+// listPostgresCommentSubtreeMemoIDs returns the target memo plus every memo
+// in its comment subtree (comments, replies to comments, and so on),
+// following COMMENT relations from parent to child.
+func listPostgresCommentSubtreeMemoIDs(ctx context.Context, tx *sql.Tx, rootMemoID int32) ([]int32, error) {
+ ids := []int32{rootMemoID}
+ seen := map[int32]struct{}{rootMemoID: {}}
+ frontier := []int32{rootMemoID}
+ for len(frontier) > 0 {
+ var next []int32
+ for _, batch := range deleteUserBatches(frontier, deleteUserBatchSize) {
+ clause, args := deleteUserInClause(1, batch)
+ if err := func() error {
+ rows, err := tx.QueryContext(ctx, "SELECT memo_id FROM memo_relation WHERE type = 'COMMENT' AND related_memo_id IN "+clause, args...)
+ if err != nil {
+ return errors.Wrap(err, "failed to list comment memos")
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var childID int32
+ if err := rows.Scan(&childID); err != nil {
+ return errors.Wrap(err, "failed to read comment memo id")
+ }
+ if _, ok := seen[childID]; ok {
+ continue
+ }
+ seen[childID] = struct{}{}
+ next = append(next, childID)
+ }
+ return errors.Wrap(rows.Err(), "failed to list comment memos")
+ }(); err != nil {
+ return nil, err
+ }
+ }
+ // Comment creation takes the same memo locks before adding replies.
+ locked, err := lockPostgresCommentMemoIDs(ctx, tx, next)
+ if err != nil {
+ return nil, err
+ }
+ ids = append(ids, locked...)
+ frontier = locked
+ }
+ return ids, nil
+}
+
+func lockPostgresCommentMemoIDs(ctx context.Context, tx *sql.Tx, ids []int32) ([]int32, error) {
+ locked := make([]int32, 0, len(ids))
+ for _, batch := range deleteUserBatches(ids, deleteUserBatchSize) {
+ clause, args := deleteUserInClause(1, batch)
+ if err := func() error {
+ rows, err := tx.QueryContext(ctx, "SELECT id FROM memo WHERE id IN "+clause+" ORDER BY id FOR UPDATE", args...)
+ if err != nil {
+ return err
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var id int32
+ if err := rows.Scan(&id); err != nil {
+ return err
+ }
+ locked = append(locked, id)
+ }
+ return rows.Err()
+ }(); err != nil {
+ return nil, errors.Wrap(err, "failed to lock comment memos")
+ }
+ }
+ return locked, nil
+}
diff --git a/store/db/sqlite/memo_delete_policy.go b/store/db/sqlite/memo_delete_policy.go
index 0332fa715..8fb776e89 100644
--- a/store/db/sqlite/memo_delete_policy.go
+++ b/store/db/sqlite/memo_delete_policy.go
@@ -52,7 +52,11 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
}
actorCanRead := store.MemoDeleteActorCanRead(rowStatus, visibility, spaceID, spaceExists, actorMember || actor.Admin)
- attachments, err := deleteSQLiteMemoSetTx(ctx, tx, []int32{delete.MemoID})
+ deleteIDs, err := listSQLiteCommentSubtreeMemoIDs(ctx, tx, delete.MemoID)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to collect comment memos")
+ }
+ attachments, err := deleteSQLiteMemoSetTx(ctx, tx, deleteIDs)
if err != nil {
return nil, errors.Wrap(err, "failed to delete memo set")
}
@@ -61,3 +65,42 @@ func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoW
}
return &store.DeleteMemoWithPolicyResult{ActorCanRead: actorCanRead, Attachments: attachments}, nil
}
+
+// listSQLiteCommentSubtreeMemoIDs returns the target memo plus every memo in
+// its comment subtree (comments, replies to comments, and so on), following
+// COMMENT relations from parent to child.
+func listSQLiteCommentSubtreeMemoIDs(ctx context.Context, tx dbExecutor, rootMemoID int32) ([]int32, error) {
+ ids := []int32{rootMemoID}
+ seen := map[int32]struct{}{rootMemoID: {}}
+ frontier := []int32{rootMemoID}
+ for len(frontier) > 0 {
+ var next []int32
+ for _, batch := range deleteUserBatches(frontier, deleteUserBatchSize) {
+ clause, args := deleteUserInClause(1, batch)
+ if err := func() error {
+ rows, err := tx.QueryContext(ctx, "SELECT memo_id FROM memo_relation WHERE type = 'COMMENT' AND related_memo_id IN "+clause, args...)
+ if err != nil {
+ return errors.Wrap(err, "failed to list comment memos")
+ }
+ defer rows.Close()
+ for rows.Next() {
+ var childID int32
+ if err := rows.Scan(&childID); err != nil {
+ return errors.Wrap(err, "failed to read comment memo id")
+ }
+ if _, ok := seen[childID]; ok {
+ continue
+ }
+ seen[childID] = struct{}{}
+ ids = append(ids, childID)
+ next = append(next, childID)
+ }
+ return errors.Wrap(rows.Err(), "failed to list comment memos")
+ }(); err != nil {
+ return nil, err
+ }
+ }
+ frontier = next
+ }
+ return ids, nil
+}
diff --git a/store/memo_delete_policy.go b/store/memo_delete_policy.go
index d5632ca4e..1d530dc21 100644
--- a/store/memo_delete_policy.go
+++ b/store/memo_delete_policy.go
@@ -7,8 +7,9 @@ import (
)
// DeleteMemoWithPolicy identifies one memo to delete atomically on behalf of
-// its author or an instance administrator. Relations do not confer lifecycle
-// authority, so no related memo is deleted.
+// its author or an instance administrator. The memo's comment subtree
+// (comments and their nested replies) is deleted with it; other relations do
+// not confer lifecycle authority.
type DeleteMemoWithPolicy struct {
MemoID int32
ActorUserID int32
@@ -40,8 +41,9 @@ func MemoDeleteActorCanRead(rowStatus RowStatus, visibility Visibility, spaceID
}
}
-// DeleteMemoWithPolicy atomically deletes exactly one memo, its owned database
-// resources, and relations for which it is an endpoint.
+// DeleteMemoWithPolicy atomically deletes one memo, its whole comment
+// subtree, their owned database resources, and relations for which any of
+// them is an endpoint.
func (s *Store) DeleteMemoWithPolicy(ctx context.Context, delete *DeleteMemoWithPolicy) (*DeleteMemoWithPolicyResult, error) {
if delete == nil || delete.MemoID <= 0 || delete.ActorUserID <= 0 {
return nil, errors.New("memo deletion requires memo and actor")
diff --git a/store/test/memo_delete_policy_test.go b/store/test/memo_delete_policy_test.go
index b0724f1b1..6fdb98d99 100644
--- a/store/test/memo_delete_policy_test.go
+++ b/store/test/memo_delete_policy_test.go
@@ -4,6 +4,7 @@ import (
"context"
"fmt"
"testing"
+ "time"
"github.com/stretchr/testify/require"
@@ -59,11 +60,12 @@ func TestDeleteMemoWithPolicyDeletesOnlyTargetAndIncidentResources(t *testing.T)
deleted, err := ts.GetMemo(ctx, &store.FindMemo{ID: &comment.ID})
require.NoError(t, err)
require.Nil(t, deleted)
- for _, survivorID := range []int32{contextMemo.ID, reply.ID} {
- survivor, err := ts.GetMemo(ctx, &store.FindMemo{ID: &survivorID})
- require.NoError(t, err)
- require.NotNil(t, survivor)
- }
+ deletedReply, err := ts.GetMemo(ctx, &store.FindMemo{ID: &reply.ID})
+ require.NoError(t, err)
+ require.Nil(t, deletedReply, "a reply is part of the deleted memo's comment subtree")
+ survivor, err := ts.GetMemo(ctx, &store.FindMemo{ID: &contextMemo.ID})
+ require.NoError(t, err)
+ require.NotNil(t, survivor)
gotAttachment, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID})
require.NoError(t, err)
@@ -83,7 +85,221 @@ func TestDeleteMemoWithPolicyDeletesOnlyTargetAndIncidentResources(t *testing.T)
require.Empty(t, incident)
replyRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &reply.ID})
require.NoError(t, err)
- require.Empty(t, replyRelations, "the surviving reply loses only its deleted context relation")
+ require.Empty(t, replyRelations, "the deleted reply's context relation is removed with it")
+}
+
+func TestDeleteMemoWithPolicyDeletesWholeCommentSubtree(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+
+ author, err := ts.CreateUser(ctx, &store.User{Username: "delete-subtree-author", Role: store.RoleUser, PasswordHash: "hash"})
+ require.NoError(t, err)
+ commenter, err := ts.CreateUser(ctx, &store.User{Username: "delete-subtree-commenter", Role: store.RoleUser, PasswordHash: "hash"})
+ require.NoError(t, err)
+
+ parent, err := ts.CreateMemo(ctx, &store.Memo{UID: "delete-subtree-parent", CreatorID: author.ID, Content: "parent", Visibility: store.Public})
+ require.NoError(t, err)
+ comment, err := ts.CreateMemoComment(ctx, &store.Memo{UID: "delete-subtree-comment", CreatorID: commenter.ID, Content: "comment", Visibility: store.Public}, parent.ID, commenter.ID)
+ require.NoError(t, err)
+ reply, err := ts.CreateMemoComment(ctx, &store.Memo{UID: "delete-subtree-reply", CreatorID: author.ID, Content: "reply", Visibility: store.Public}, comment.ID, author.ID)
+ require.NoError(t, err)
+ unrelated, err := ts.CreateMemo(ctx, &store.Memo{UID: "delete-subtree-unrelated", CreatorID: commenter.ID, Content: "unrelated", Visibility: store.Public})
+ require.NoError(t, err)
+
+ result, err := ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: parent.ID, ActorUserID: author.ID})
+ require.NoError(t, err)
+ require.True(t, result.ActorCanRead)
+
+ for _, deletedID := range []int32{parent.ID, comment.ID, reply.ID} {
+ deleted, err := ts.GetMemo(ctx, &store.FindMemo{ID: &deletedID})
+ require.NoError(t, err)
+ require.Nil(t, deleted, "memo %d should be deleted with the parent", deletedID)
+ }
+ survivor, err := ts.GetMemo(ctx, &store.FindMemo{ID: &unrelated.ID})
+ require.NoError(t, err)
+ require.NotNil(t, survivor)
+
+ remaining, err := ts.ListMemos(ctx, &store.FindMemo{CreatorID: &commenter.ID, ExcludeComments: true})
+ require.NoError(t, err)
+ for _, memo := range remaining {
+ require.NotEqual(t, comment.ID, memo.ID, "a deleted comment must not resurface as a top-level memo")
+ }
+}
+
+type memoDeleteRaceFixture struct {
+ store *store.Store
+ owner, commenter *store.User
+ parent, comment, reply *store.Memo
+}
+
+func newMemoDeleteRaceFixture(t *testing.T) *memoDeleteRaceFixture {
+ t.Helper()
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ t.Cleanup(func() { require.NoError(t, ts.Close()) })
+ owner, err := ts.CreateUser(ctx, &store.User{Username: "delete-race-owner", Role: store.RoleUser, PasswordHash: "hash"})
+ require.NoError(t, err)
+ commenter, err := ts.CreateUser(ctx, &store.User{Username: "delete-race-commenter", Role: store.RoleUser, PasswordHash: "hash"})
+ require.NoError(t, err)
+ parent, err := ts.CreateMemo(ctx, &store.Memo{UID: "delete-race-parent", CreatorID: owner.ID, Content: "parent", Visibility: store.Public})
+ require.NoError(t, err)
+ comment, err := ts.CreateMemoComment(ctx, &store.Memo{UID: "delete-race-comment", CreatorID: commenter.ID, Content: "comment", Visibility: store.Public}, parent.ID, commenter.ID)
+ require.NoError(t, err)
+ reply, err := ts.CreateMemoComment(ctx, &store.Memo{UID: "delete-race-reply", CreatorID: owner.ID, Content: "reply", Visibility: store.Public}, comment.ID, owner.ID)
+ require.NoError(t, err)
+ return &memoDeleteRaceFixture{store: ts, owner: owner, commenter: commenter, parent: parent, comment: comment, reply: reply}
+}
+
+func TestDeleteMemoWithPolicyBlocksNewRepliesDuringSubtreeDeletion(t *testing.T) {
+ driver := getDriverFromEnv()
+ if driver == "sqlite" || driver == "d1" {
+ t.Skip("SQLite serializes writes with IMMEDIATE transactions; D1 has no row locks")
+ }
+
+ fixture := newMemoDeleteRaceFixture(t)
+ ts, owner, commenter := fixture.store, fixture.owner, fixture.commenter
+ parent, comment, reply := fixture.parent, fixture.comment, fixture.reply
+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+ defer cancel()
+ share, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: "delete-race-share", MemoID: parent.ID, CreatorID: owner.ID})
+ require.NoError(t, err)
+
+ // Hold share cleanup so deletion keeps the whole subtree locked while a
+ // writer tries to add a reply to its deepest memo.
+ blocker, err := ts.GetDriver().GetDB().BeginTx(ctx, nil)
+ require.NoError(t, err)
+ blockerOpen := true
+ defer func() {
+ if blockerOpen {
+ _ = blocker.Rollback()
+ }
+ }()
+ query := "SELECT id FROM memo_share WHERE id = ? FOR UPDATE"
+ if driver == "postgres" {
+ query = "SELECT id FROM memo_share WHERE id = $1 FOR UPDATE"
+ }
+ var shareID int32
+ require.NoError(t, blocker.QueryRowContext(ctx, query, share.ID).Scan(&shareID))
+
+ deleteDone := make(chan error, 1)
+ go func() {
+ _, deleteErr := ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: parent.ID, ActorUserID: owner.ID})
+ deleteDone <- deleteErr
+ }()
+ select {
+ case deleteErr := <-deleteDone:
+ require.FailNowf(t, "deletion ended before locking the subtree", "error: %v", deleteErr)
+ case <-time.After(100 * time.Millisecond):
+ }
+ for _, memoID := range []int32{parent.ID, comment.ID, reply.ID} {
+ waitForLockedParentRow(ctx, t, ts.GetDriver().GetDB(), driver, "memo", memoID)
+ require.NoError(t, ctx.Err())
+ }
+
+ lateCtx, lateCancel := context.WithTimeout(ctx, 300*time.Millisecond)
+ started := time.Now()
+ _, createErr := ts.CreateMemoComment(lateCtx, &store.Memo{UID: "delete-race-late-reply", CreatorID: commenter.ID, Content: "late reply", Visibility: store.Public}, reply.ID, commenter.ID)
+ lateCancel()
+ require.Error(t, createErr)
+ require.GreaterOrEqual(t, time.Since(started), 250*time.Millisecond, "reply creation must wait for subtree deletion: %v", createErr)
+
+ require.NoError(t, blocker.Commit())
+ blockerOpen = false
+ select {
+ case deleteErr := <-deleteDone:
+ require.NoError(t, deleteErr)
+ case <-ctx.Done():
+ require.FailNow(t, "timed out waiting for memo deletion")
+ }
+ for _, uid := range []string{parent.UID, comment.UID, reply.UID, "delete-race-late-reply"} {
+ memo, err := ts.GetMemo(ctx, &store.FindMemo{UID: &uid})
+ require.NoError(t, err)
+ require.Nil(t, memo, "memo %s must not survive subtree deletion", uid)
+ }
+}
+
+func TestDeleteMemoWithPolicyIncludesReplyCommittedWhileWaitingForSubtree(t *testing.T) {
+ driver := getDriverFromEnv()
+ if driver == "sqlite" || driver == "d1" {
+ t.Skip("SQLite serializes writes with IMMEDIATE transactions; D1 has no row locks")
+ }
+
+ fixture := newMemoDeleteRaceFixture(t)
+ ts, owner, commenter := fixture.store, fixture.owner, fixture.commenter
+ parent, comment, reply := fixture.parent, fixture.comment, fixture.reply
+ ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+ defer cancel()
+ attachment, err := ts.CreateAttachment(ctx, &store.Attachment{
+ UID: "delete-race-attachment", CreatorID: commenter.ID, Filename: "late.txt", Type: "text/plain", Blob: []byte("x"),
+ })
+ require.NoError(t, err)
+
+ // Pause reply creation after it locks the context memo but before it commits.
+ blocker, err := ts.GetDriver().GetDB().BeginTx(ctx, nil)
+ require.NoError(t, err)
+ blockerOpen := true
+ defer func() {
+ if blockerOpen {
+ _ = blocker.Rollback()
+ }
+ }()
+ query := "SELECT id FROM attachment WHERE id = ? FOR UPDATE"
+ if driver == "postgres" {
+ query = "SELECT id FROM attachment WHERE id = $1 FOR UPDATE"
+ }
+ var attachmentID int32
+ require.NoError(t, blocker.QueryRowContext(ctx, query, attachment.ID).Scan(&attachmentID))
+
+ late := &store.Memo{UID: "delete-race-committed-reply", CreatorID: commenter.ID, Content: "late reply", Visibility: store.Public}
+ createDone := make(chan error, 1)
+ go func() {
+ createDone <- ts.ApplyMemoMutation(ctx, &store.MemoMutation{
+ MemoCreate: late, CommentContextMemoID: &reply.ID,
+ Bindings: []*store.MemoAttachmentBinding{{ID: attachment.ID, UID: attachment.UID, UpdatedTs: time.Now().Unix()}},
+ RequiredAttachmentIDs: []int32{attachment.ID},
+ })
+ }()
+ waitForLockedParentRow(ctx, t, ts.GetDriver().GetDB(), driver, "memo", reply.ID)
+ require.NoError(t, ctx.Err())
+
+ deleteDone := make(chan error, 1)
+ go func() {
+ _, deleteErr := ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: parent.ID, ActorUserID: owner.ID})
+ deleteDone <- deleteErr
+ }()
+ for _, memoID := range []int32{parent.ID, comment.ID} {
+ waitForLockedParentRow(ctx, t, ts.GetDriver().GetDB(), driver, "memo", memoID)
+ require.NoError(t, ctx.Err())
+ }
+ select {
+ case deleteErr := <-deleteDone:
+ require.FailNowf(t, "deletion ended before reply creation committed", "error: %v", deleteErr)
+ default:
+ }
+
+ require.NoError(t, blocker.Commit())
+ blockerOpen = false
+ select {
+ case createErr := <-createDone:
+ require.NoError(t, createErr)
+ case <-ctx.Done():
+ require.FailNow(t, "timed out waiting for reply creation")
+ }
+ select {
+ case deleteErr := <-deleteDone:
+ require.NoError(t, deleteErr)
+ case <-ctx.Done():
+ require.FailNow(t, "timed out waiting for memo deletion")
+ }
+ for _, uid := range []string{parent.UID, comment.UID, reply.UID, late.UID} {
+ memo, err := ts.GetMemo(ctx, &store.FindMemo{UID: &uid})
+ require.NoError(t, err)
+ require.Nil(t, memo, "memo %s must not survive subtree deletion", uid)
+ }
+ gotAttachment, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID})
+ require.NoError(t, err)
+ require.Nil(t, gotAttachment, "the committed reply's attachment must be deleted with it")
}
func TestMemoDeleteActorCanReadAudienceMatrix(t *testing.T) {
diff --git a/web/src/types/proto/api/v1/memo_service_pb.ts b/web/src/types/proto/api/v1/memo_service_pb.ts
index 36abc19f0..4955af37d 100644
--- a/web/src/types/proto/api/v1/memo_service_pb.ts
+++ b/web/src/types/proto/api/v1/memo_service_pb.ts
@@ -1296,8 +1296,9 @@ export const MemoService: GenService<{
output: typeof MemoSchema;
},
/**
- * DeleteMemo deletes only the named memo and its owned resources. It removes
- * incident relations but never deletes another memo.
+ * DeleteMemo deletes the named memo and its comment subtree, including nested
+ * replies and their owned resources. It removes incident relations for all
+ * deleted memos.
*
* @generated from rpc memos.api.v1.MemoService.DeleteMemo
*/