Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

refactor: prevent DONE status changes and optimize batch operations (#18688)

Danny Xu92b2bfea28c5
diff --git a/backend/api/v1/issue_service.go b/backend/api/v1/issue_service.go
index a99cf549d1..19ec722828 100644
--- a/backend/api/v1/issue_service.go
+++ b/backend/api/v1/issue_service.go
@@ -12,7 +12,6 @@ import (
celast "github.com/google/cel-go/common/ast"
celoperators "github.com/google/cel-go/common/operators"
"github.com/pkg/errors"
- "go.uber.org/multierr"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
@@ -658,23 +657,17 @@ func (s *IssueService) ApproveIssue(ctx context.Context, req *connect.Request[v1
// TODO(p0ny): Post project IAM policy update activity.
}
- if err := func() error {
- p := &storepb.IssueCommentPayload{
+ if _, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{
+ IssueUID: issue.UID,
+ Payload: &storepb.IssueCommentPayload{
Comment: req.Msg.Comment,
Event: &storepb.IssueCommentPayload_Approval_{
Approval: &storepb.IssueCommentPayload_Approval{
Status: storepb.IssuePayloadApproval_Approver_APPROVED,
},
},
- }
- if _, err := s.store.CreateIssueComment(ctx, &store.IssueCommentMessage{
- IssueUID: issue.UID,
- Payload: p,
- }, user.Email); err != nil {
- return err
- }
- return nil
- }(); err != nil {
+ },
+ }); err != nil {
slog.Warn("failed to create issue comment", log.BBError(err))
}
@@ -836,21 +829,17 @@ func (s *IssueService) RejectIssue(ctx context.Context, req *connect.Request[v1p
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to update issue"))
}
- if err := func() error {
- p := &storepb.IssueCommentPayload{
+ if _, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{
+ IssueUID: issue.UID,
+ Payload: &storepb.IssueCommentPayload{
Comment: req.Msg.Comment,
Event: &storepb.IssueCommentPayload_Approval_{
Approval: &storepb.IssueCommentPayload_Approval{
Status: storepb.IssuePayloadApproval_Approver_REJECTED,
},
},
- }
- _, err := s.store.CreateIssueComment(ctx, &store.IssueCommentMessage{
- IssueUID: issue.UID,
- Payload: p,
- }, user.Email)
- return err
- }(); err != nil {
+ },
+ }); err != nil {
slog.Warn("failed to create issue comment", log.BBError(err))
}
@@ -942,23 +931,17 @@ func (s *IssueService) RequestIssue(ctx context.Context, req *connect.Request[v1
})
}()
- if err := func() error {
- p := &storepb.IssueCommentPayload{
+ if _, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{
+ IssueUID: issue.UID,
+ Payload: &storepb.IssueCommentPayload{
Comment: req.Msg.Comment,
Event: &storepb.IssueCommentPayload_Approval_{
Approval: &storepb.IssueCommentPayload_Approval{
Status: storepb.IssuePayloadApproval_Approver_PENDING,
},
},
- }
- if _, err := s.store.CreateIssueComment(ctx, &store.IssueCommentMessage{
- IssueUID: issue.UID,
- Payload: p,
- }, user.Email); err != nil {
- return err
- }
- return nil
- }(); err != nil {
+ },
+ }); err != nil {
slog.Warn("failed to create issue comment", log.BBError(err))
}
@@ -1141,10 +1124,8 @@ func (s *IssueService) UpdateIssue(ctx context.Context, req *connect.Request[v1p
for _, e := range webhookEvents {
s.webhookManager.CreateEvent(ctx, e)
}
- for _, create := range issueCommentCreates {
- if _, err := s.store.CreateIssueComment(ctx, create, user.Email); err != nil {
- slog.Warn("failed to create issue comment", "issue id", issue.UID, log.BBError(err))
- }
+ if _, err := s.store.CreateIssueComments(ctx, user.Email, issueCommentCreates...); err != nil {
+ slog.Warn("failed to create issue comments", "issue id", issue.UID, log.BBError(err))
}
issueV1, err := s.convertToIssue(issue)
@@ -1161,95 +1142,92 @@ func (s *IssueService) BatchUpdateIssuesStatus(ctx context.Context, req *connect
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
- var issueIDs []int
- var issues []*store.IssueMessage
- for _, issueName := range req.Msg.Issues {
- issue, err := s.getIssueMessage(ctx, issueName)
+ if len(req.Msg.Issues) == 0 {
+ return connect.NewResponse(&v1pb.BatchUpdateIssuesStatusResponse{}), nil
+ }
+
+ newStatus, err := convertToAPIIssueStatus(req.Msg.Status)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to issue status, err: %v", err))
+ }
+
+ // Parse issue names and validate all issues belong to the same project.
+ var projectID string
+ issueUIDs := make([]int, 0, len(req.Msg.Issues))
+ for i, issueName := range req.Msg.Issues {
+ issueProjectID, issueUID, err := common.GetProjectIDIssueUID(issueName)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find issue %v, err: %v", issueName, err))
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid issue name %q: %v", issueName, err))
}
- if issue == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("cannot find issue %v", issueName))
- }
- issueIDs = append(issueIDs, issue.UID)
- issues = append(issues, issue)
- // Check if there is any running/pending task runs.
- if issue.PlanUID != nil {
- taskRunStatusList := []storepb.TaskRun_Status{storepb.TaskRun_RUNNING, storepb.TaskRun_PENDING}
- taskRuns, err := s.store.ListTaskRuns(ctx, &store.FindTaskRunMessage{PlanUID: issue.PlanUID, Status: &taskRunStatusList})
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list task runs, err: %v", err))
- }
- if len(taskRuns) > 0 {
- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("cannot update status because there are running/pending task runs for issue %q, cancel the task runs first", issueName))
- }
+ // Ensure all issues belong to the same project.
+ if i == 0 {
+ projectID = issueProjectID
+ } else if issueProjectID != projectID {
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("all issues must belong to the same project, found %q and %q", projectID, issueProjectID))
}
- }
- if len(issueIDs) == 0 {
- return connect.NewResponse(&v1pb.BatchUpdateIssuesStatusResponse{}), nil
+ issueUIDs = append(issueUIDs, issueUID)
}
- newStatus, err := convertToAPIIssueStatus(req.Msg.Status)
+ // Get project early for webhooks.
+ project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &projectID})
if err != nil {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to issue status, err: %v", err))
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get project: %v", err))
+ }
+ if project == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %q not found", projectID))
}
- if err := s.store.BatchUpdateIssueStatuses(ctx, issueIDs, newStatus); err != nil {
+ // Batch update issue statuses. This validates project membership, DONE status, and returns old statuses.
+ oldIssueStatuses, err := s.store.BatchUpdateIssueStatuses(ctx, projectID, issueUIDs, newStatus)
+ if err != nil {
+ if common.ErrorCode(err) == common.Invalid {
+ return nil, connect.NewError(connect.CodeFailedPrecondition, err)
+ }
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to batch update issues, err: %v", err))
}
- if err := func() error {
- var errs error
- for _, issue := range issues {
- updatedIssue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{UID: &issue.UID})
- if err != nil {
- errs = multierr.Append(errs, errors.Wrapf(err, "failed to get issue %v", issue.UID))
- continue
- }
- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{ResourceID: &updatedIssue.ProjectID})
- if err != nil {
- errs = multierr.Append(errs, errors.Wrapf(err, "failed to get project for issue %v", issue.UID))
- continue
- }
- if project == nil {
- errs = multierr.Append(errs, errors.Errorf("project %s not found for issue %v", updatedIssue.ProjectID, issue.UID))
- continue
- }
-
- func() {
- s.webhookManager.CreateEvent(ctx, &webhook.Event{
- Actor: user,
- Type: storepb.Activity_ISSUE_STATUS_UPDATE,
- Comment: req.Msg.Reason,
- Issue: webhook.NewIssue(updatedIssue),
- Project: webhook.NewProject(project),
- })
- }()
-
- func() {
- fromStatus := convertToIssueStatus(issue.Status)
- if _, err := s.store.CreateIssueComment(ctx, &store.IssueCommentMessage{
- IssueUID: issue.UID,
- Payload: &storepb.IssueCommentPayload{
- Comment: req.Msg.Reason,
- Event: &storepb.IssueCommentPayload_IssueUpdate_{
- IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{
- FromStatus: convertToIssueCommentPayloadIssueUpdateIssueStatus(&fromStatus),
- ToStatus: convertToIssueCommentPayloadIssueUpdateIssueStatus(&req.Msg.Status),
- },
- },
+ // Batch create issue comments.
+ issueComments := make([]*store.IssueCommentMessage, 0, len(issueUIDs))
+ for _, issueUID := range issueUIDs {
+ oldStatus := oldIssueStatuses[issueUID]
+ issueComments = append(issueComments, &store.IssueCommentMessage{
+ IssueUID: issueUID,
+ Payload: &storepb.IssueCommentPayload{
+ Comment: req.Msg.Reason,
+ Event: &storepb.IssueCommentPayload_IssueUpdate_{
+ IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{
+ FromStatus: &oldStatus,
+ ToStatus: &newStatus,
},
- }, user.Email); err != nil {
- errs = multierr.Append(errs, errors.Wrapf(err, "failed to create issue comment after change the issue status"))
- return
- }
- }()
+ },
+ },
+ })
+ }
+ if _, err := s.store.CreateIssueComments(ctx, user.Email, issueComments...); err != nil {
+ slog.Error("failed to batch create issue comments", log.BBError(err))
+ }
+
+ // Create webhooks for each updated issue.
+ for _, issueUID := range issueUIDs {
+ updatedIssue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{UID: &issueUID, ProjectID: &projectID})
+ if err != nil {
+ slog.Error("failed to get updated issue", "issueUID", issueUID, log.BBError(err))
+ continue
}
- return errs
- }(); err != nil {
- slog.Error("failed to create activity after changing the issue status", log.BBError(err))
+ if updatedIssue == nil {
+ slog.Error("updated issue not found", "issueUID", issueUID)
+ continue
+ }
+
+ s.webhookManager.CreateEvent(ctx, &webhook.Event{
+ Actor: user,
+ Type: storepb.Activity_ISSUE_STATUS_UPDATE,
+ Comment: req.Msg.Reason,
+ Issue: webhook.NewIssue(updatedIssue),
+ Project: webhook.NewProject(project),
+ })
}
return connect.NewResponse(&v1pb.BatchUpdateIssuesStatusResponse{}), nil
@@ -1336,12 +1314,12 @@ func (s *IssueService) CreateIssueComment(ctx context.Context, req *connect.Requ
Project: webhook.NewProject(project),
})
- ic, err := s.store.CreateIssueComment(ctx, &store.IssueCommentMessage{
+ ic, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{
IssueUID: issue.UID,
Payload: &storepb.IssueCommentPayload{
Comment: req.Msg.IssueComment.Comment,
},
- }, user.Email)
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to create issue comment: %v", err))
}
diff --git a/backend/api/v1/issue_service_converter.go b/backend/api/v1/issue_service_converter.go
index 3e08a14a84..0a110090c7 100644
--- a/backend/api/v1/issue_service_converter.go
+++ b/backend/api/v1/issue_service_converter.go
@@ -344,26 +344,6 @@ func convertToIssueCommentEventIssueUpdate(u *storepb.IssueCommentPayload_IssueU
}
}
-func convertToIssueCommentPayloadIssueUpdateIssueStatus(s *v1pb.IssueStatus) *storepb.Issue_Status {
- if s == nil {
- return nil
- }
- var is storepb.Issue_Status
- switch *s {
- case v1pb.IssueStatus_CANCELED:
- is = storepb.Issue_CANCELED
- case v1pb.IssueStatus_DONE:
- is = storepb.Issue_DONE
- case v1pb.IssueStatus_OPEN:
- is = storepb.Issue_OPEN
- case v1pb.IssueStatus_ISSUE_STATUS_UNSPECIFIED:
- is = storepb.Issue_ISSUE_STATUS_UNSPECIFIED
- default:
- is = storepb.Issue_ISSUE_STATUS_UNSPECIFIED
- }
- return &is
-}
-
func convertToIssueCommentEventIssueUpdateStatus(s *storepb.Issue_Status) *v1pb.IssueStatus {
if s == nil {
return nil
diff --git a/backend/runner/taskrun/scheduler.go b/backend/runner/taskrun/scheduler.go
index 64a1a9e1df..35dccb2b67 100644
--- a/backend/runner/taskrun/scheduler.go
+++ b/backend/runner/taskrun/scheduler.go
@@ -237,7 +237,7 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {
fromStatus := storepb.Issue_Status(storepb.Issue_Status_value[issueN.Status.String()])
toStatus := storepb.Issue_Status(storepb.Issue_Status_value[updatedIssue.Status.String()])
- if _, err := s.store.CreateIssueComment(ctx, &store.IssueCommentMessage{
+ if _, err := s.store.CreateIssueComments(ctx, common.SystemBotEmail, &store.IssueCommentMessage{
IssueUID: issueN.UID,
Payload: &storepb.IssueCommentPayload{
Event: &storepb.IssueCommentPayload_IssueUpdate_{
@@ -247,7 +247,7 @@ func (s *Scheduler) ListenTaskSkippedOrDone(ctx context.Context) {
},
},
},
- }, common.SystemBotEmail); err != nil {
+ }); err != nil {
return errors.Wrapf(err, "failed to create issue comment after changing the issue status")
}
diff --git a/backend/store/issue.go b/backend/store/issue.go
index c8d7ee08e9..d08789b8bf 100644
--- a/backend/store/issue.go
+++ b/backend/store/issue.go
@@ -367,28 +367,71 @@ func (s *Store) ListIssues(ctx context.Context, find *FindIssueMessage) ([]*Issu
}
// BatchUpdateIssueStatuses updates the status of multiple issues.
-func (s *Store) BatchUpdateIssueStatuses(ctx context.Context, issueUIDs []int, status storepb.Issue_Status) error {
- // Update the statuses
- updateQuery := qb.Q().Space("UPDATE issue SET status = ? WHERE id = ANY(?)", status.String(), issueUIDs)
- updateSQL, updateArgs, err := updateQuery.ToSQL()
+// Returns a map of issueUID -> old status for the updated issues.
+func (s *Store) BatchUpdateIssueStatuses(ctx context.Context, projectID string, issueUIDs []int, newStatus storepb.Issue_Status) (map[int]storepb.Issue_Status, error) {
+ tx, err := s.GetDB().BeginTx(ctx, nil)
if err != nil {
- return errors.Wrapf(err, "failed to build update sql")
+ return nil, errors.Wrapf(err, "failed to begin transaction")
}
+ defer tx.Rollback()
- tx, err := s.GetDB().BeginTx(ctx, nil)
+ // Fetch current issues to validate project membership and get old statuses.
+ fetchQuery := qb.Q().Space("SELECT id, status FROM issue WHERE id = ANY(?) AND project = ?", issueUIDs, projectID)
+ fetchSQL, fetchArgs, err := fetchQuery.ToSQL()
if err != nil {
- return errors.Wrapf(err, "failed to begin transaction")
+ return nil, errors.Wrapf(err, "failed to build fetch sql")
+ }
+
+ rows, err := tx.QueryContext(ctx, fetchSQL, fetchArgs...)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to fetch issues")
+ }
+ defer rows.Close()
+
+ oldStatuses := make(map[int]storepb.Issue_Status)
+ for rows.Next() {
+ var issueID int
+ var statusString string
+ if err := rows.Scan(&issueID, &statusString); err != nil {
+ return nil, errors.Wrapf(err, "failed to scan issue")
+ }
+ statusValue, ok := storepb.Issue_Status_value[statusString]
+ if !ok {
+ return nil, errors.Errorf("invalid status string: %s", statusString)
+ }
+ issueStatus := storepb.Issue_Status(statusValue)
+
+ // Prevent changing status from DONE to other statuses.
+ if issueStatus == storepb.Issue_DONE && newStatus != storepb.Issue_DONE {
+ return nil, &common.Error{Code: common.Invalid, Err: errors.Errorf("cannot change status from DONE to %s for issue %d", newStatus.String(), issueID)}
+ }
+
+ oldStatuses[issueID] = issueStatus
+ }
+ if err := rows.Err(); err != nil {
+ return nil, errors.Wrapf(err, "failed to iterate rows")
+ }
+
+ // Validate that all requested issues were found in the project.
+ if len(oldStatuses) != len(issueUIDs) {
+ return nil, &common.Error{Code: common.Invalid, Err: errors.Errorf("expected %d issues in project %s, found %d", len(issueUIDs), projectID, len(oldStatuses))}
+ }
+
+ // Update the statuses.
+ updateQuery := qb.Q().Space("UPDATE issue SET status = ? WHERE id = ANY(?) AND project = ?", newStatus.String(), issueUIDs, projectID)
+ updateSQL, updateArgs, err := updateQuery.ToSQL()
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to build update sql")
}
- defer tx.Rollback()
if _, err := tx.ExecContext(ctx, updateSQL, updateArgs...); err != nil {
- return errors.Wrapf(err, "failed to update")
+ return nil, errors.Wrapf(err, "failed to update")
}
if err := tx.Commit(); err != nil {
- return errors.Wrapf(err, "failed to commit")
+ return nil, errors.Wrapf(err, "failed to commit")
}
- return nil
+ return oldStatuses, nil
}
func getTSVector(text string) string {
diff --git a/backend/store/issue_comment.go b/backend/store/issue_comment.go
index c98d37cdf3..05c1e66bfe 100644
--- a/backend/store/issue_comment.go
+++ b/backend/store/issue_comment.go
@@ -118,36 +118,59 @@ func (s *Store) ListIssueComment(ctx context.Context, find *FindIssueCommentMess
return issueComments, nil
}
-func (s *Store) CreateIssueComment(ctx context.Context, create *IssueCommentMessage, creator string) (*IssueCommentMessage, error) {
- payload, err := protojson.Marshal(create.Payload)
- if err != nil {
- return nil, errors.Wrapf(err, "failed to marshal payload")
+// CreateIssueComments creates one or more issue comments.
+// For a single comment, it returns the created comment with UID, CreatedAt, and UpdatedAt filled in.
+// For multiple comments, it performs a batch insert and returns nil.
+func (s *Store) CreateIssueComments(ctx context.Context, creator string, creates ...*IssueCommentMessage) (*IssueCommentMessage, error) {
+ if len(creates) == 0 {
+ return nil, nil
}
+ // Prepare all payloads.
+ issueIDs := make([]int, 0, len(creates))
+ payloads := make([][]byte, 0, len(creates))
+ for _, create := range creates {
+ payload, err := protojson.Marshal(create.Payload)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to marshal payload")
+ }
+ issueIDs = append(issueIDs, create.IssueUID)
+ payloads = append(payloads, payload)
+ }
+
+ // Use UNNEST to insert all comments in one query.
q := qb.Q().Space(`
- INSERT INTO issue_comment (
- creator,
- issue_id,
- payload
- ) VALUES (
- ?,
- ?,
- ?
- ) RETURNING id, created_at, updated_at
- `, creator, create.IssueUID, payload)
+ INSERT INTO issue_comment (creator, issue_id, payload)
+ SELECT ?, unnest(?::INT[]), unnest(?::JSONB[])
+ `, creator, issueIDs, payloads)
+
+ // For single comment, use RETURNING to get the created comment details.
+ if len(creates) == 1 {
+ q.Space("RETURNING id, created_at, updated_at")
+ query, args, err := q.ToSQL()
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to build sql")
+ }
+ create := creates[0]
+ if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(&create.UID, &create.CreatedAt, &create.UpdatedAt); err != nil {
+ return nil, errors.Wrapf(err, "failed to insert")
+ }
+ create.CreatorEmail = creator
+ return create, nil
+ }
+
+ // For multiple comments, just execute without RETURNING.
query, args, err := q.ToSQL()
if err != nil {
return nil, errors.Wrapf(err, "failed to build sql")
}
- if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(&create.UID, &create.CreatedAt, &create.UpdatedAt); err != nil {
- return nil, errors.Wrapf(err, "failed to insert")
+ if _, err := s.GetDB().ExecContext(ctx, query, args...); err != nil {
+ return nil, errors.Wrapf(err, "failed to batch insert comments")
}
- create.CreatorEmail = creator
-
- return create, nil
+ return nil, nil
}
func (s *Store) UpdateIssueComment(ctx context.Context, patch *UpdateIssueCommentMessage) error {
diff --git a/backend/tests/database.go b/backend/tests/database.go
index 0e6cb053ea..b1f6325d4f 100644
--- a/backend/tests/database.go
+++ b/backend/tests/database.go
@@ -61,17 +61,5 @@ func (ctl *controller) createDatabase(ctx context.Context, project *v1pb.Project
return err
}
- if err := ctl.waitRollout(ctx, issueResp.Msg.Name, rolloutResp.Msg.Name); err != nil {
- return err
- }
-
- _, err = ctl.issueServiceClient.BatchUpdateIssuesStatus(ctx, connect.NewRequest(&v1pb.BatchUpdateIssuesStatusRequest{
- Parent: project.Name,
- Issues: []string{issueResp.Msg.Name},
- Status: v1pb.IssueStatus_DONE,
- }))
- if err != nil {
- return err
- }
- return nil
+ return ctl.waitRollout(ctx, issueResp.Msg.Name, rolloutResp.Msg.Name)
}