Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: centralize transactional issue review workflow (#20916)
p0ny4e0500b90bd7
diff --git a/backend/api/v1/issue_hook.go b/backend/api/v1/issue_hook.goindex bf64ea7fa0..13a6cd92c4 100644--- a/backend/api/v1/issue_hook.go+++ b/backend/api/v1/issue_hook.go@@ -9,10 +9,10 @@ import ("github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/common/log""github.com/bytebase/bytebase/backend/component/bus"+ "github.com/bytebase/bytebase/backend/component/review""github.com/bytebase/bytebase/backend/component/webhook""github.com/bytebase/bytebase/backend/enterprise"storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/runner/approval""github.com/bytebase/bytebase/backend/store""github.com/bytebase/bytebase/backend/utils")@@ -49,16 +49,18 @@ func postCreateIssue(storepb.Issue_ROLE_GRANT,storepb.Issue_DATABASE_EXPORT:- if err := approval.FindAndApplyApprovalTemplate(ctx, stores, webhookManager, licenseService, issue); err != nil {+ result, err := review.FindAndApplyApprovalTemplate(ctx, stores, licenseService, issue)+ if err != nil {slog.Error("failed to find approval template",slog.String("project", issue.ProjectID), slog.Int64("issue_uid", issue.UID),slog.String("issue_title", issue.Title),log.BBError(err))+ } else {+ review.DispatchApprovalEvents(ctx, stores, webhookManager, result)}// Refresh issue to get updated approval payload.uid := issue.UID- var err errorissue, err = stores.GetIssue(ctx, &store.FindIssueMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ProjectIDs: []string{issue.ProjectID}, UID: &uid})if err != nil {return nil, errors.Wrapf(err, "failed to refresh issue")diff --git a/backend/api/v1/issue_review.go b/backend/api/v1/issue_review.gonew file mode 100644index 0000000000..2d8c0a14a6--- /dev/null+++ b/backend/api/v1/issue_review.go@@ -0,0 +1,145 @@+package v1++import (+ "context"+ "log/slog"++ "connectrpc.com/connect"+ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/log"+ "github.com/bytebase/bytebase/backend/component/bus"+ "github.com/bytebase/bytebase/backend/component/review"+ "github.com/bytebase/bytebase/backend/component/webhook"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+)++// ApproveIssue approves the approval flow of the issue.+func (s *IssueService) ApproveIssue(ctx context.Context, req *connect.Request[v1pb.ApproveIssueRequest]) (*connect.Response[v1pb.Issue], error) {+ return s.reviewIssue(ctx, req.Msg.Name, req.Msg.Comment, review.ActionApprove)+}++// RejectIssue rejects an issue.+func (s *IssueService) RejectIssue(ctx context.Context, req *connect.Request[v1pb.RejectIssueRequest]) (*connect.Response[v1pb.Issue], error) {+ return s.reviewIssue(ctx, req.Msg.Name, req.Msg.Comment, review.ActionReject)+}++// RequestIssue requests an issue after rejection.+func (s *IssueService) RequestIssue(ctx context.Context, req *connect.Request[v1pb.RequestIssueRequest]) (*connect.Response[v1pb.Issue], error) {+ return s.reviewIssue(ctx, req.Msg.Name, req.Msg.Comment, review.ActionRequest)+}++func (s *IssueService) reviewIssue(ctx context.Context, name, comment string, action review.Action) (*connect.Response[v1pb.Issue], error) {+ projectID, issueUID, err := common.GetProjectIDIssueUID(name)+ if err != nil {+ return nil, connect.NewError(connect.CodeInvalidArgument, err)+ }+ user, ok := GetUserFromContext(ctx)+ if !ok {+ return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))+ }+ result, err := s.reviewWorkflow.ReviewIssue(ctx, review.IssueInput{+ Workspace: common.GetWorkspaceIDFromContext(ctx),+ ProjectID: projectID,+ IssueUID: issueUID,+ Actor: user,+ Action: action,+ Comment: comment,+ })+ if err != nil {+ return nil, mapReviewError(err, action)+ }++ createRollout := false+ for _, event := range result.Events {+ switch event := event.(type) {+ case review.IssueCommentEvent:+ if _, err := s.store.CreateIssueComments(ctx, event.ActorEmail, &store.IssueCommentMessage{+ ProjectID: result.Issue.ProjectID,+ IssueUID: result.Issue.UID,+ Payload: &storepb.IssueCommentPayload{+ Comment: event.Comment,+ Event: &storepb.IssueCommentPayload_Approval_{+ Approval: &storepb.IssueCommentPayload_Approval{Status: event.ApprovalStatus},+ },+ },+ }); err != nil {+ slog.Warn("failed to create issue comment", log.BBError(err))+ }+ case review.ApprovalRequestedEvent:+ review.NotifyApprovalRequested(ctx, s.store, s.webhookManager, result.Issue, result.Project)+ case review.IssueApprovedEvent:+ review.NotifyIssueApproved(ctx, s.store, s.webhookManager, result.Issue, result.Project, user)+ case review.IssueSentBackEvent:+ creator, err := s.store.GetAccountByEmail(ctx, result.Issue.CreatorEmail)+ if err != nil {+ slog.Warn("failed to get issue creator", log.BBError(err))+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get issue creator"))+ }+ s.webhookManager.CreateEvent(ctx, &webhook.Event{+ Type: storepb.Activity_ISSUE_SENT_BACK,+ Project: webhook.NewProject(result.Project),+ SentBack: &webhook.EventIssueSentBack{+ Approver: &webhook.User{Name: user.Name, Email: user.Email, Phone: user.Phone},+ Creator: &webhook.User{Name: creator.Name, Email: creator.Email, Phone: creator.Phone},+ Issue: webhook.NewIssue(result.Issue),+ Reason: comment,+ },+ })+ case review.CompleteAccessRequestEvent:+ completed, err := completeAccessRequestIssue(ctx, s.store, user.Email, result.Issue)+ if err != nil {+ slog.Debug("failed to complete role grant issue", log.BBError(err))+ } else {+ result.Issue = completed+ }+ case review.CreateRolloutEvent:+ createRollout = true+ default:+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("unexpected review event %T", event))+ }+ }++ converted, err := s.convertToIssue(result.Issue)+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to convert to issue"))+ }+ if createRollout && result.Issue.PlanUID != nil {+ s.bus.RolloutCreationChan <- bus.PlanRef{ProjectID: result.Issue.ProjectID, PlanID: *result.Issue.PlanUID}+ }+ return connect.NewResponse(converted), nil+}++func mapReviewError(err error, action review.Action) error {+ var workflowErr *review.Error+ if !errors.As(err, &workflowErr) {+ return connect.NewError(connect.CodeInternal, err)+ }+ switch workflowErr.Code {+ case review.ErrorNotFound:+ return connect.NewError(connect.CodeNotFound, workflowErr)+ case review.ErrorInvalidAction:+ return connect.NewError(connect.CodeInvalidArgument, workflowErr)+ case review.ErrorFailedPrecondition:+ return connect.NewError(connect.CodeFailedPrecondition, workflowErr)+ case review.ErrorPermissionDenied:+ return connect.NewError(connect.CodePermissionDenied, workflowErr)+ case review.ErrorConflict:+ message := "cannot request issue because approval finding is stale"+ switch action {+ case review.ActionApprove:+ message = "cannot approve because approval finding is stale"+ case review.ActionReject:+ message = "cannot reject because approval finding is stale"+ case review.ActionRequest:+ default:+ return connect.NewError(connect.CodeInternal, errors.Errorf("unexpected review action %d", action))+ }+ return connect.NewError(connect.CodeFailedPrecondition, errors.New(message))+ default:+ return connect.NewError(connect.CodeInternal, workflowErr)+ }+}diff --git a/backend/api/v1/issue_service.go b/backend/api/v1/issue_service.goindex d88642b859..d7a3175a04 100644--- a/backend/api/v1/issue_service.go+++ b/backend/api/v1/issue_service.go@@ -4,7 +4,6 @@ import ("context""fmt""log/slog"- "slices""strings""time"@@ -19,12 +18,12 @@ import ("github.com/bytebase/bytebase/backend/common/permission""github.com/bytebase/bytebase/backend/component/bus""github.com/bytebase/bytebase/backend/component/iam"+ "github.com/bytebase/bytebase/backend/component/review""github.com/bytebase/bytebase/backend/component/webhook""github.com/bytebase/bytebase/backend/enterprise"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"- "github.com/bytebase/bytebase/backend/runner/approval""github.com/bytebase/bytebase/backend/store""github.com/bytebase/bytebase/backend/utils")@@ -37,10 +36,9 @@ type IssueService struct {bus *bus.BuslicenseService *enterprise.LicenseServiceiamManager *iam.Manager+ reviewWorkflow *review.Workflow}-var errStaleApprovalFinding = errors.New("stale approval finding")-type filterIssueMessage struct {ApprovalStatus *v1pb.ApprovalStatus// Approver is the user who can approve the issue.@@ -61,6 +59,7 @@ func NewIssueService(bus: bus,licenseService: licenseService,iamManager: iamManager,+ reviewWorkflow: review.NewWorkflow(store),}}@@ -687,373 +686,6 @@ func (s *IssueService) getSubmittedIssueForApprovalAction(ctx context.Context, nreturn issue, nil}-// ApproveIssue approves the approval flow of the issue.-func (s *IssueService) ApproveIssue(ctx context.Context, req *connect.Request[v1pb.ApproveIssueRequest]) (*connect.Response[v1pb.Issue], error) {- issue, err := s.getSubmittedIssueForApprovalAction(ctx, req.Msg.Name)- if err != nil {- return nil, err- }- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ResourceID: &issue.ProjectID})- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get project"))- }- if project == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", issue.ProjectID))- }- payload := issue.Payload- if payload.Approval == nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("issue payload approval is nil"))- }- if !payload.Approval.ApprovalFindingDone {- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("approval template finding is not done"))- }- if payload.Approval.ApprovalTemplate == nil {- return nil, connect.NewError(connect.CodeInternal, errors.New("approval template is required"))- }-- plan, approvalInputVersion, err := s.getIssuePlanApprovalInputVersion(ctx, issue)- if err != nil {- return nil, err- }-- rejectedRole := utils.FindRejectedRole(payload.Approval)- if rejectedRole != "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("cannot approve because the issue has been rejected"))- }-- role := utils.FindNextPendingRole(payload.Approval)- if role == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("the issue has been approved"))- }-- user, ok := GetUserFromContext(ctx)- if !ok {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))- }-- canApprove := s.isUserReviewer(ctx, issue, role, user)- if !canApprove {- return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("cannot approve because the user does not have the required permission"))- }-- if !project.Setting.GetAllowSelfApproval() && issue.CreatorEmail == user.Email {- return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("cannot approve because self-approval is not allowed for this project"))- }-- payload.Approval.Approvers = append(payload.Approval.Approvers, &storepb.IssuePayloadApproval_Approver{- Status: storepb.IssuePayloadApproval_Approver_APPROVED,- Principal: common.FormatUserEmail(user.Email),- })-- approved, err := utils.CheckIssueApprovedForPlan(issue, plan)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check if the approval is approved"))- }-- issue, err = s.updateIssueApprovalPayload(ctx, issue, &storepb.Issue{Approval: payload.Approval}, plan, approvalInputVersion)- if err != nil {- if errors.Is(err, errStaleApprovalFinding) {- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("cannot approve because approval finding is stale"))- }- return nil, connect.NewError(connect.CodeInternal, err)- }- if plan != nil {- plan, _, err = s.getIssuePlanApprovalInputVersion(ctx, issue)- if err != nil {- return nil, err- }- approved, err = utils.CheckIssueApprovedForPlan(issue, plan)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check if the approval is approved"))- }- }-- if _, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{- ProjectID: issue.ProjectID,- IssueUID: issue.UID,- Payload: &storepb.IssueCommentPayload{- Comment: req.Msg.Comment,- Event: &storepb.IssueCommentPayload_Approval_{- Approval: &storepb.IssueCommentPayload_Approval{- Status: storepb.IssuePayloadApproval_Approver_APPROVED,- },- },- },- }); err != nil {- slog.Warn("failed to create issue comment", log.BBError(err))- }-- approval.NotifyApprovalRequested(ctx, s.store, s.webhookManager, issue, project)-- // If the issue is approved, notify the creator and complete access request if applicable.- if approved {- approval.NotifyIssueApproved(ctx, s.store, s.webhookManager, issue, project, user)- issue, err = completeAccessRequestIssue(ctx, s.store, user.Email, issue)- if err != nil {- slog.Debug("failed to complete role grant issue", log.BBError(err))- }- }-- issueV1, err := s.convertToIssue(issue)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to issue"))- }-- // Auto-create rollout if this approval completes the approval flow- if issueV1.ApprovalStatus == v1pb.ApprovalStatus_APPROVED {- if issue.PlanUID != nil {- s.bus.RolloutCreationChan <- bus.PlanRef{ProjectID: issue.ProjectID, PlanID: *issue.PlanUID}- }- }-- return connect.NewResponse(issueV1), nil-}--// RejectIssue rejects a issue.-func (s *IssueService) RejectIssue(ctx context.Context, req *connect.Request[v1pb.RejectIssueRequest]) (*connect.Response[v1pb.Issue], error) {- issue, err := s.getSubmittedIssueForApprovalAction(ctx, req.Msg.Name)- if err != nil {- return nil, err- }- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ResourceID: &issue.ProjectID})- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get project"))- }- if project == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", issue.ProjectID))- }- payload := issue.Payload- if payload.Approval == nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("issue payload approval is nil"))- }- if !payload.Approval.ApprovalFindingDone {- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("approval template finding is not done"))- }- if payload.Approval.ApprovalTemplate == nil {- return nil, connect.NewError(connect.CodeInternal, errors.New("approval template is required"))- }-- plan, approvalInputVersion, err := s.getIssuePlanApprovalInputVersion(ctx, issue)- if err != nil {- return nil, err- }-- rejectedRole := utils.FindRejectedRole(payload.Approval)- if rejectedRole != "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("cannot reject because the issue has been rejected"))- }-- role := utils.FindNextPendingRole(payload.Approval)- if role == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("the issue has been approved"))- }-- user, ok := GetUserFromContext(ctx)- if !ok {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))- }-- canApprove := s.isUserReviewer(ctx, issue, role, user)- if !canApprove {- return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("cannot reject because the user does not have the required permission"))- }-- if !project.Setting.GetAllowSelfApproval() && issue.CreatorEmail == user.Email {- return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("cannot reject because self-approval is not allowed for this project"))- }-- payload.Approval.Approvers = append(payload.Approval.Approvers, &storepb.IssuePayloadApproval_Approver{- Status: storepb.IssuePayloadApproval_Approver_REJECTED,- Principal: common.FormatUserEmail(user.Email),- })-- issue, err = s.updateIssueApprovalPayload(ctx, issue, &storepb.Issue{Approval: payload.Approval}, plan, approvalInputVersion)- if err != nil {- if errors.Is(err, errStaleApprovalFinding) {- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("cannot reject because approval finding is stale"))- }- return nil, connect.NewError(connect.CodeInternal, err)- }-- if _, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{- ProjectID: issue.ProjectID,- IssueUID: issue.UID,- Payload: &storepb.IssueCommentPayload{- Comment: req.Msg.Comment,- Event: &storepb.IssueCommentPayload_Approval_{- Approval: &storepb.IssueCommentPayload_Approval{- Status: storepb.IssuePayloadApproval_Approver_REJECTED,- },- },- },- }); err != nil {- slog.Warn("failed to create issue comment", log.BBError(err))- }-- creatorAccount, err := s.store.GetAccountByEmail(ctx, issue.CreatorEmail)- if err != nil {- slog.Warn("failed to get issue creator", log.BBError(err))- return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get issue creator"))- }-- // Trigger ISSUE_SENT_BACK webhook- s.webhookManager.CreateEvent(ctx, &webhook.Event{- Type: storepb.Activity_ISSUE_SENT_BACK,- Project: webhook.NewProject(project),- SentBack: &webhook.EventIssueSentBack{- Approver: &webhook.User{- Name: user.Name,- Email: user.Email,- Phone: user.Phone,- },- Creator: &webhook.User{- Name: creatorAccount.Name,- Email: creatorAccount.Email,- Phone: creatorAccount.Phone,- },- Issue: webhook.NewIssue(issue),- Reason: req.Msg.Comment,- },- })-- issueV1, err := s.convertToIssue(issue)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to issue"))- }- return connect.NewResponse(issueV1), nil-}--// RequestIssue requests a issue.-func (s *IssueService) RequestIssue(ctx context.Context, req *connect.Request[v1pb.RequestIssueRequest]) (*connect.Response[v1pb.Issue], error) {- issue, err := s.getSubmittedIssueForApprovalAction(ctx, req.Msg.Name)- if err != nil {- return nil, err- }- project, err := s.store.GetProject(ctx, &store.FindProjectMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ResourceID: &issue.ProjectID})- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get project"))- }- if project == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", issue.ProjectID))- }- payload := issue.Payload- if payload.Approval == nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("issue payload approval is nil"))- }- if !payload.Approval.ApprovalFindingDone {- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("approval template finding is not done"))- }- if payload.Approval.ApprovalTemplate == nil {- return nil, connect.NewError(connect.CodeInternal, errors.New("approval template is required"))- }-- plan, approvalInputVersion, err := s.getIssuePlanApprovalInputVersion(ctx, issue)- if err != nil {- return nil, err- }-- rejectedRole := utils.FindRejectedRole(payload.Approval)- if rejectedRole == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("cannot request issues because the issue is not rejected"))- }-- user, ok := GetUserFromContext(ctx)- if !ok {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))- }-- canRequest := canRequestIssue(issue.CreatorEmail, user)- if !canRequest {- return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("cannot request issues because you are not the issue creator"))- }-- var updatedApprovers []*storepb.IssuePayloadApproval_Approver- for _, approver := range payload.Approval.Approvers {- if approver.Status == storepb.IssuePayloadApproval_Approver_REJECTED {- continue- }- updatedApprovers = append(updatedApprovers, approver)- }- payload.Approval.Approvers = updatedApprovers-- issue, err = s.updateIssueApprovalPayload(ctx, issue, &storepb.Issue{Approval: payload.Approval}, plan, approvalInputVersion)- if err != nil {- if errors.Is(err, errStaleApprovalFinding) {- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("cannot request issue because approval finding is stale"))- }- return nil, connect.NewError(connect.CodeInternal, err)- }-- approval.NotifyApprovalRequested(ctx, s.store, s.webhookManager, issue, project)-- if _, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{- ProjectID: issue.ProjectID,- IssueUID: issue.UID,- Payload: &storepb.IssueCommentPayload{- Comment: req.Msg.Comment,- Event: &storepb.IssueCommentPayload_Approval_{- Approval: &storepb.IssueCommentPayload_Approval{- Status: storepb.IssuePayloadApproval_Approver_PENDING,- },- },- },- }); err != nil {- slog.Warn("failed to create issue comment", log.BBError(err))- }-- issueV1, err := s.convertToIssue(issue)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to issue"))- }- return connect.NewResponse(issueV1), nil-}--func (s *IssueService) getIssuePlanApprovalInputVersion(ctx context.Context, issue *store.IssueMessage) (*store.PlanMessage, int64, error) {- if issue.Type != storepb.Issue_DATABASE_CHANGE || issue.PlanUID == nil {- return nil, 0, nil- }-- plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{ProjectID: issue.ProjectID, UID: issue.PlanUID})- if err != nil {- return nil, 0, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get plan"))- }- if plan == nil {- return nil, 0, connect.NewError(connect.CodeNotFound, errors.New("plan not found"))- }- if plan.Config == nil {- return plan, 0, nil- }- return plan, plan.Config.GetApprovalInputVersion(), nil-}--func (s *IssueService) updateIssueApprovalPayload(ctx context.Context, issue *store.IssueMessage, payloadPatch *storepb.Issue, plan *store.PlanMessage, approvalInputVersion int64) (*store.IssueMessage, error) {- if plan == nil {- updatedIssue, err := s.store.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: payloadPatch,- })- if err != nil {- return nil, errors.Wrapf(err, "failed to update issue")- }- return updatedIssue, nil- }-- updatedIssue, err := s.store.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: payloadPatch,- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireIssueApprovalInputVersion: &approvalInputVersion,- })- if err != nil {- if errors.Is(err, store.ErrIssueUpdateSkipped) {- return nil, errStaleApprovalFinding- }- return nil, errors.Wrapf(err, "failed to update issue")- }- if updatedIssue == nil {- return nil, errors.New("issue not found after update")- }- return updatedIssue, nil-}-// RetryIssueApproval re-runs approval-template finding for an issue stuck// in CHECKING. The synchronous post-create path in `postCreateIssue`// swallows errors (e.g. CEL evaluation failure against a malformed@@ -1105,11 +737,13 @@ func (s *IssueService) RetryIssueApproval(ctx context.Context, req *connect.Requreturn connect.NewResponse(issueV1), nil}- if err := approval.FindAndApplyApprovalTemplate(ctx, s.store, s.webhookManager, s.licenseService, issue); err != nil {+ approvalResult, err := review.FindAndApplyApprovalTemplate(ctx, s.store, s.licenseService, issue)+ if err != nil {// Surface the underlying cause (e.g. CEL error in the workspace// approval rule) so the operator can fix it.return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Wrap(err, "approval finding still failing"))}+ review.DispatchApprovalEvents(ctx, s.store, s.webhookManager, approvalResult)uid := issue.UIDrefreshed, err := s.store.GetIssue(ctx, &store.FindIssueMessage{@@ -1212,118 +846,85 @@ func (s *IssueService) UpdateIssue(ctx context.Context, req *connect.Request[v1preturn nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", issue.ProjectID))}- updateMasks := map[string]bool{}-- patch := &store.UpdateIssueMessage{}- hasDirectIssueUpdate := false+ metadataInput := review.UpdateIssueMetadataInput{+ Workspace: common.GetWorkspaceIDFromContext(ctx),+ ProjectID: issue.ProjectID,+ IssueUID: issue.UID,+ }+ hasMetadataPatch := falsevar issueCommentCreates []*store.IssueCommentMessage- var labelsChangedWithApprovalReset bool- var labelsForApprovalReset []stringfor _, path := range req.Msg.UpdateMask.Paths {- updateMasks[path] = trueswitch path {case "title":trimmed := strings.TrimSpace(req.Msg.Issue.Title)if trimmed == "" {return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("title cannot be empty"))}- if trimmed == issue.Title {- // No-op update — skip both the patch and the audit comment so we- // don't pollute the timeline with "changed name from X to X".- continue- }-- patch.Title = &trimmed- hasDirectIssueUpdate = true-- issueCommentCreates = append(issueCommentCreates, &store.IssueCommentMessage{- IssueUID: issue.UID,- Payload: &storepb.IssueCommentPayload{- Event: &storepb.IssueCommentPayload_IssueUpdate_{- IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{- FromTitle: &issue.Title,- ToTitle: &trimmed,- },- },- },- })+ metadataInput.Title = &trimmed+ hasMetadataPatch = truecase "description":- if req.Msg.Issue.Description == issue.Description {- continue- }- patch.Description = &req.Msg.Issue.Description- hasDirectIssueUpdate = true-- issueCommentCreates = append(issueCommentCreates, &store.IssueCommentMessage{- IssueUID: issue.UID,- Payload: &storepb.IssueCommentPayload{- Event: &storepb.IssueCommentPayload_IssueUpdate_{- IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{- FromDescription: &issue.Description,- ToDescription: &req.Msg.Issue.Description,- },- },- },- })+ metadataInput.Description = &req.Msg.Issue.Description+ hasMetadataPatch = truecase "labels":- labels := store.CanonicalizeIssueLabels(req.Msg.Issue.Labels)- if slices.Equal(issue.Payload.Labels, labels) {- continue- }- resetApprovalForLabels, err := s.shouldResetApprovalForIssueLabels(ctx, issue)- if err != nil {- return nil, err- }- if resetApprovalForLabels {- labelsChangedWithApprovalReset = true- labelsForApprovalReset = labels- } else {- if len(labels) == 0 {- patch.RemoveLabels = true- } else {- if patch.PayloadUpsert == nil {- patch.PayloadUpsert = &storepb.Issue{}- }- patch.PayloadUpsert.Labels = labels- }- hasDirectIssueUpdate = true- }+ labels := append([]string(nil), req.Msg.Issue.Labels...)+ metadataInput.Labels = &labels+ hasMetadataPatch = true- issueCommentCreates = append(issueCommentCreates, &store.IssueCommentMessage{- IssueUID: issue.UID,- Payload: &storepb.IssueCommentPayload{- Event: &storepb.IssueCommentPayload_IssueUpdate_{- IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{- FromLabels: issue.Payload.Labels,- ToLabels: labels,- },- },- },- })default:}}- if hasDirectIssueUpdate {- issue, err = s.store.UpdateIssue(ctx, issue.ProjectID, issue.UID, patch)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to update issue"))- }- }-- if labelsChangedWithApprovalReset {- updatedIssue, approvalResetApplied, err := s.store.UpdateIssueLabelsAndMaybeResetApproval(ctx, issue.ProjectID, issue.UID, labelsForApprovalReset)+ if hasMetadataPatch {+ result, err := s.reviewWorkflow.UpdateIssueMetadata(ctx, metadataInput)if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to update issue labels"))- }- if updatedIssue == nil {- return nil, connect.NewError(connect.CodeNotFound, errors.New("issue not found after issue label update"))+ return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to update issue"))}- issue = updatedIssue- if approvalResetApplied {- s.bus.ApprovalCheckChan <- bus.IssueRef{ProjectID: issue.ProjectID, UID: issue.UID}+ issue = result.Issue+ for _, event := range result.Events {+ switch event := event.(type) {+ case review.IssueTitleUpdatedEvent:+ issueCommentCreates = append(issueCommentCreates, &store.IssueCommentMessage{+ IssueUID: issue.UID,+ Payload: &storepb.IssueCommentPayload{+ Event: &storepb.IssueCommentPayload_IssueUpdate_{+ IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{+ FromTitle: &event.FromTitle,+ ToTitle: &event.ToTitle,+ },+ },+ },+ })+ case review.IssueDescriptionUpdatedEvent:+ issueCommentCreates = append(issueCommentCreates, &store.IssueCommentMessage{+ IssueUID: issue.UID,+ Payload: &storepb.IssueCommentPayload{+ Event: &storepb.IssueCommentPayload_IssueUpdate_{+ IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{+ FromDescription: &event.FromDescription,+ ToDescription: &event.ToDescription,+ },+ },+ },+ })+ case review.IssueLabelsUpdatedEvent:+ issueCommentCreates = append(issueCommentCreates, &store.IssueCommentMessage{+ IssueUID: issue.UID,+ Payload: &storepb.IssueCommentPayload{+ Event: &storepb.IssueCommentPayload_IssueUpdate_{+ IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{+ FromLabels: event.FromLabels,+ ToLabels: event.ToLabels,+ },+ },+ },+ })+ case review.ApprovalCheckEvent:+ s.bus.ApprovalCheckChan <- bus.IssueRef{ProjectID: issue.ProjectID, UID: issue.UID}+ default:+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("unexpected issue metadata event %T", event))+ }}}@@ -1341,29 +942,6 @@ func (s *IssueService) UpdateIssue(ctx context.Context, req *connect.Request[v1preturn connect.NewResponse(issueV1), nil}-func (s *IssueService) shouldResetApprovalForIssueLabels(ctx context.Context, issue *store.IssueMessage) (bool, error) {- if issue.Payload.GetDraft() {- return false, nil- }-- if issue.Type != storepb.Issue_DATABASE_CHANGE || issue.PlanUID == nil {- return false, nil- }- plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{ProjectID: issue.ProjectID, UID: issue.PlanUID})- if err != nil {- return false, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get plan for issue label update"))- }- if plan == nil {- return false, connect.NewError(connect.CodeNotFound, errors.New("plan not found for issue label update"))- }- for _, spec := range plan.Config.GetSpecs() {- if _, ok := spec.Config.(*storepb.PlanConfig_Spec_ChangeDatabaseConfig); ok {- return true, nil- }- }- return false, nil-}-// BatchUpdateIssuesStatus batch updates issues status.func (s *IssueService) BatchUpdateIssuesStatus(ctx context.Context, req *connect.Request[v1pb.BatchUpdateIssuesStatusRequest]) (*connect.Response[v1pb.BatchUpdateIssuesStatusResponse], error) {user, ok := GetUserFromContext(ctx)@@ -1619,11 +1197,6 @@ func (s *IssueService) getIssueMessage(ctx context.Context, name string) (*storereturn issue, nil}-func (s *IssueService) isUserReviewer(ctx context.Context, issue *store.IssueMessage, role string, user *store.UserMessage) bool {- roles := s.getUserRoleMap(ctx, issue.ProjectID, user)- return roles[role]-}-func canRequestIssue(issueCreatorEmail string, user *store.UserMessage) bool {return issueCreatorEmail == user.Email}diff --git a/backend/api/v1/issue_service_test.go b/backend/api/v1/issue_service_test.goindex 5fa1a4f826..e050973a5a 100644--- a/backend/api/v1/issue_service_test.go+++ b/backend/api/v1/issue_service_test.go@@ -9,11 +9,13 @@ import ("connectrpc.com/connect""github.com/stretchr/testify/assert""github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto""google.golang.org/protobuf/types/known/fieldmaskpb""github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/common/testcontainer""github.com/bytebase/bytebase/backend/component/bus"+ "github.com/bytebase/bytebase/backend/component/review"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/migrator"@@ -57,10 +59,15 @@ func TestUpdateIssueLabelsDoesNotResetApprovalAfterRollout(t *testing.T) {service := newIssueServiceForTest(t, stores)plan, issue := createIssueServiceApprovalIssue(ctx, t, stores)- approvalInputVersion := int64(2)- marked, _, err := stores.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)+ _, err := review.NewWorkflow(stores).CreateRollout(ctx, review.CreateRolloutInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ BuildTasks: func(context.Context, *store.PlanMessage, *store.ProjectMessage) ([]*store.TaskMessage, error) {+ return nil, nil+ },+ })require.NoError(t, err)- require.True(t, marked)updateIssueLabels(ctx, t, service, issue, []string{"environment:staging"})@@ -71,11 +78,228 @@ func TestUpdateIssueLabelsDoesNotResetApprovalAfterRollout(t *testing.T) {require.Len(t, service.bus.ApprovalCheckChan, 0)}+func TestConcurrentIdenticalLabelUpdatesCreateOneAuditComment(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ service := newIssueServiceForTest(t, stores)+ _, issue := createIssueServiceApprovalIssue(ctx, t, stores)++ for i := range 10 {+ labels := []string{fmt.Sprintf("iteration:%d", i)}+ start := make(chan struct{})+ errs := make(chan error, 2)+ var wg sync.WaitGroup+ for range 2 {+ wg.Go(func() {+ <-start+ _, err := service.UpdateIssue(ctx, connect.NewRequest(&v1pb.UpdateIssueRequest{+ Issue: &v1pb.Issue{+ Name: common.FormatIssue(issue.ProjectID, issue.UID),+ Labels: labels,+ },+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"labels"}},+ }))+ errs <- err+ })+ }+ close(start)+ wg.Wait()+ close(errs)+ for err := range errs {+ require.NoError(t, err)+ }+ }++ comments, err := stores.ListIssueComment(ctx, &store.FindIssueCommentMessage{+ ProjectID: "project-a",+ IssueUID: &issue.UID,+ })+ require.NoError(t, err)+ require.Len(t, comments, 10)+}++func TestConcurrentIdenticalTitleUpdatesCreateOneAuditComment(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ service := newIssueServiceForTest(t, stores)+ _, issue := createIssueServiceApprovalIssue(ctx, t, stores)+ start := make(chan struct{})+ errs := make(chan error, 2)+ var wg sync.WaitGroup+ for range 2 {+ wg.Go(func() {+ <-start+ _, err := service.UpdateIssue(ctx, connect.NewRequest(&v1pb.UpdateIssueRequest{+ Issue: &v1pb.Issue{+ Name: common.FormatIssue(issue.ProjectID, issue.UID),+ Title: "renamed issue",+ },+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title"}},+ }))+ errs <- err+ })+ }+ close(start)+ wg.Wait()+ close(errs)+ for err := range errs {+ require.NoError(t, err)+ }++ comments, err := stores.ListIssueComment(ctx, &store.FindIssueCommentMessage{+ ProjectID: issue.ProjectID,+ IssueUID: &issue.UID,+ })+ require.NoError(t, err)+ require.Len(t, comments, 1)+ update := comments[0].Payload.GetIssueUpdate()+ require.Equal(t, "issue-a", update.GetFromTitle())+ require.Equal(t, "renamed issue", update.GetToTitle())+}++func TestMixedIssuePatchRollsBackWhenLabelsFail(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ service := newIssueServiceForTest(t, stores)+ _, issue := createIssueServiceApprovalIssue(ctx, t, stores)+ _, err := stores.GetDB().ExecContext(ctx, `+ ALTER TABLE issue ADD CONSTRAINT reject_atomic_test_label+ CHECK (NOT COALESCE(payload->'labels' ? 'reject', false))`)+ require.NoError(t, err)++ _, err = service.UpdateIssue(ctx, connect.NewRequest(&v1pb.UpdateIssueRequest{+ Issue: &v1pb.Issue{+ Name: common.FormatIssue(issue.ProjectID, issue.UID),+ Title: "renamed issue",+ Description: "updated description",+ Labels: []string{"reject"},+ },+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title", "description", "labels"}},+ }))+ require.Equal(t, connect.CodeInternal, connect.CodeOf(err))++ got := getIssueForTest(ctx, t, stores, issue.UID)+ require.Equal(t, "issue-a", got.Title)+ require.Empty(t, got.Description)+ require.Equal(t, []string{"environment:prod"}, got.Payload.GetLabels())+ comments, err := stores.ListIssueComment(ctx, &store.FindIssueCommentMessage{+ ProjectID: issue.ProjectID,+ IssueUID: &issue.UID,+ })+ require.NoError(t, err)+ require.Empty(t, comments)+}++func TestMixedIssuePatchCommitsWithAuditComments(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ service := newIssueServiceForTest(t, stores)+ _, issue := createIssueServiceApprovalIssue(ctx, t, stores)++ response, err := service.UpdateIssue(ctx, connect.NewRequest(&v1pb.UpdateIssueRequest{+ Issue: &v1pb.Issue{+ Name: common.FormatIssue(issue.ProjectID, issue.UID),+ Title: "renamed issue",+ Description: "updated description",+ Labels: []string{"environment:staging"},+ },+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title", "description", "labels"}},+ }))+ require.NoError(t, err)+ require.Equal(t, "renamed issue", response.Msg.Title)+ require.Equal(t, "updated description", response.Msg.Description)+ require.Equal(t, []string{"environment:staging"}, response.Msg.Labels)++ got := getIssueForTest(ctx, t, stores, issue.UID)+ require.False(t, got.Payload.GetApproval().GetApprovalFindingDone())+ require.Len(t, service.bus.ApprovalCheckChan, 1)+ comments, err := stores.ListIssueComment(ctx, &store.FindIssueCommentMessage{+ ProjectID: issue.ProjectID,+ IssueUID: &issue.UID,+ })+ require.NoError(t, err)+ require.Len(t, comments, 3)+ var titleAudit, descriptionAudit, labelsAudit bool+ for _, comment := range comments {+ update := comment.Payload.GetIssueUpdate()+ require.NotNil(t, update)+ switch {+ case update.FromTitle != nil:+ titleAudit = true+ require.Equal(t, "issue-a", update.GetFromTitle())+ require.Equal(t, "renamed issue", update.GetToTitle())+ case update.FromDescription != nil:+ descriptionAudit = true+ require.Empty(t, update.GetFromDescription())+ require.Equal(t, "updated description", update.GetToDescription())+ default:+ labelsAudit = true+ require.Equal(t, []string{"environment:prod"}, update.GetFromLabels())+ require.Equal(t, []string{"environment:staging"}, update.GetToLabels())+ }+ }+ require.True(t, titleAudit)+ require.True(t, descriptionAudit)+ require.True(t, labelsAudit)+}++func TestIssueMetadataNoopDoesNotCreateAuditComments(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ service := newIssueServiceForTest(t, stores)+ _, issue := createIssueServiceApprovalIssue(ctx, t, stores)++ _, err := service.UpdateIssue(ctx, connect.NewRequest(&v1pb.UpdateIssueRequest{+ Issue: &v1pb.Issue{+ Name: common.FormatIssue(issue.ProjectID, issue.UID),+ Title: " issue-a ",+ Description: "",+ Labels: []string{" environment:prod ", "environment:prod"},+ },+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title", "description", "labels"}},+ }))+ require.NoError(t, err)++ got := getIssueForTest(ctx, t, stores, issue.UID)+ require.Equal(t, issue.UpdatedAt, got.UpdatedAt)+ require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())+ require.Empty(t, service.bus.ApprovalCheckChan)+ comments, err := stores.ListIssueComment(ctx, &store.FindIssueCommentMessage{+ ProjectID: issue.ProjectID,+ IssueUID: &issue.UID,+ })+ require.NoError(t, err)+ require.Empty(t, comments)+}++func TestApproveIssueFailsClosedWhenIAMLookupFails(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ service := newIssueServiceForTest(t, stores)+ _, issue := createIssueServiceApprovalIssue(ctx, t, stores)+ approval := proto.CloneOf(issue.Payload.GetApproval())+ approval.Approvers = nil+ _, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{+ PayloadUpsert: &storepb.Issue{Approval: approval},+ })+ require.NoError(t, err)+ _, err = stores.GetDB().ExecContext(ctx, "ALTER TABLE policy RENAME TO unavailable_policy")+ require.NoError(t, err)++ reviewerCtx := context.WithValue(ctx, common.UserContextKey, &store.UserMessage{+ Email: "[email protected]",+ Name: "reviewer",+ })+ _, err = service.ApproveIssue(reviewerCtx, connect.NewRequest(&v1pb.ApproveIssueRequest{+ Name: common.FormatIssue(issue.ProjectID, issue.UID),+ }))+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err))+}+func TestCreateRolloutAndPendingTasksAllowsUnapprovedIssueWhenApprovalNotRequired(t *testing.T) {ctx := issueServiceTestContext()stores := setupIssueServiceTestStore(ctx, t)plan, issue := createIssueServiceApprovalIssue(ctx, t, stores)- approvalInputVersion := int64(2)_, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{PayloadUpsert: &storepb.Issue{Approval: &storepb.IssuePayloadApproval{@@ -83,7 +307,6 @@ func TestCreateRolloutAndPendingTasksAllowsUnapprovedIssueWhenApprovalNotRequireApprovalInputVersion: 2,},},- RequirePlanApprovalInputVersion: &approvalInputVersion,})require.NoError(t, err)@@ -110,6 +333,38 @@ func TestCreateRolloutAndPendingTasksAllowsUnapprovedIssueWhenApprovalNotRequirerequire.Equal(t, storepb.Issue_DONE, gotIssue.Status)}+func TestCreateRolloutAndPendingTasksClassifiesApprovalRaceAsStale(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ require.NoError(t, stores.UpdateProjects(ctx, &store.UpdateProjectMessage{+ Workspace: "default",+ ResourceID: "project-a",+ Setting: &storepb.Project{RequireIssueApproval: true},+ }))+ plan, issue := createIssueServiceApprovalIssue(ctx, t, stores)+ staleIssue := *issue+ staleIssue.Payload = proto.CloneOf(issue.Payload)++ unapproved := proto.CloneOf(issue.Payload)+ unapproved.Approval.Approvers = nil+ _, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{+ PayloadUpsert: &storepb.Issue{Approval: unapproved.Approval},+ })+ require.NoError(t, err)++ err = CreateRolloutAndPendingTasks(ctx, stores, "[email protected]", plan, &staleIssue, &store.ProjectMessage{+ Workspace: "default",+ ResourceID: "project-a",+ Setting: &storepb.Project{RequireIssueApproval: true},+ }, []*store.TaskMessage{})+ require.Error(t, err)+ require.True(t, IsStaleRolloutApprovalError(err))++ got, getErr := stores.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})+ require.NoError(t, getErr)+ require.False(t, got.Config.GetHasRollout())+}+func TestCreateRolloutAndPendingTasksRejectsDraft(t *testing.T) {ctx := issueServiceTestContext()stores := setupIssueServiceTestStore(ctx, t)@@ -422,6 +677,47 @@ func TestDraftIssueApprovalActionsRejectedBeforeApprovalValidation(t *testing.T)}}+func TestStaleReviewRequestDispatchesNoPostCommitEffects(t *testing.T) {+ ctx := issueServiceTestContext()+ stores := setupIssueServiceTestStore(ctx, t)+ service := newIssueServiceForTest(t, stores)+ plan, issue := createIssueServiceApprovalIssue(ctx, t, stores)++ staleApproval := issue.Payload.GetApproval()+ staleApproval.Approvers[0].Status = storepb.IssuePayloadApproval_Approver_REJECTED+ _, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{+ PayloadUpsert: &storepb.Issue{Approval: staleApproval},+ })+ require.NoError(t, err)+ _, err = stores.UpdatePlan(ctx, &store.UpdatePlanMessage{+ UID: plan.UID,+ ProjectID: plan.ProjectID,+ Config: &storepb.PlanConfig{+ ApprovalInputVersion: 3,+ Specs: plan.Config.GetSpecs(),+ },+ })+ require.NoError(t, err)++ for range 2 {+ _, err = service.RequestIssue(ctx, connect.NewRequest(&v1pb.RequestIssueRequest{+ Name: common.FormatIssue(issue.ProjectID, issue.UID),+ Comment: "retry",+ }))+ require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))+ }+ comments, err := stores.ListIssueComment(ctx, &store.FindIssueCommentMessage{+ ProjectID: issue.ProjectID,+ IssueUID: &issue.UID,+ })+ require.NoError(t, err)+ require.Empty(t, comments)+ require.Empty(t, service.bus.ApprovalCheckChan)+ require.Empty(t, service.bus.RolloutCreationChan)+ got := getIssueForTest(ctx, t, stores, issue.UID)+ require.True(t, got.Payload.GetApproval().Equal(staleApproval))+}+func TestCreateDraftIssue(t *testing.T) {ctx := issueServiceTestContext()stores := setupIssueServiceTestStore(ctx, t)diff --git a/backend/api/v1/plan_service.go b/backend/api/v1/plan_service.goindex e89b09fc15..8075422247 100644--- a/backend/api/v1/plan_service.go+++ b/backend/api/v1/plan_service.go@@ -8,17 +8,16 @@ import ("connectrpc.com/connect""github.com/pkg/errors"- "google.golang.org/protobuf/proto""google.golang.org/protobuf/types/known/timestamppb""github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/common/log"- "github.com/bytebase/bytebase/backend/runner/approval""github.com/bytebase/bytebase/backend/runner/plancheck""github.com/bytebase/bytebase/backend/common/permission""github.com/bytebase/bytebase/backend/component/bus""github.com/bytebase/bytebase/backend/component/iam"+ "github.com/bytebase/bytebase/backend/component/review""github.com/bytebase/bytebase/backend/component/webhook""github.com/bytebase/bytebase/backend/enterprise"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -35,6 +34,7 @@ type PlanService struct {iamManager *iam.ManagerwebhookManager *webhook.ManagerlicenseService *enterprise.LicenseService+ reviewWorkflow *review.Workflow}// NewPlanService returns a plan service instance.@@ -45,6 +45,7 @@ func NewPlanService(store *store.Store, bus *bus.Bus, iamManager *iam.Manager, wiamManager: iamManager,webhookManager: webhookManager,licenseService: licenseService,+ reviewWorkflow: review.NewWorkflow(store),}}@@ -294,15 +295,11 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[vreturn nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf("permission denied to update plan"))}- planUpdate := &store.UpdatePlanMessage{- UID: oldPlan.UID,- ProjectID: oldPlan.ProjectID,- }+ planUpdate := &store.UpdatePlanMessage{UID: oldPlan.UID, ProjectID: oldPlan.ProjectID}+ var specs []*storepb.PlanConfig_Specvar planCheckRunsTrigger boolvar databaseGroup *v1pb.DatabaseGroup- var issueCommentCreates []*store.IssueCommentMessage- var issueToReset *store.IssueMessagefor _, path := range req.UpdateMask.Paths {switch path {@@ -330,93 +327,68 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[v// Convert and store new specs.allSpecs := convertPlanSpecs(req.GetPlan().GetSpecs())- config := proto.CloneOf(oldPlan.Config)- config.Specs = allSpecs- planUpdate.Config = config- planUpdate.BumpApprovalInputVersion = true- planUpdate.RequireNoRollout = true+ specs = allSpecs// Trigger plan check runs.planCheckRunsTrigger = true-- // Evict approvals if issue exists to request re-approval.- issue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ProjectIDs: []string{projectID}, PlanUID: &oldPlan.UID})- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get issue: %v", err))- }- if issue != nil {- if !planSpecsEqualSet(oldPlan.Config.GetSpecs(), allSpecs) {- issueCommentCreates = append(issueCommentCreates, &store.IssueCommentMessage{- ProjectID: issue.ProjectID,- IssueUID: issue.UID,- Payload: &storepb.IssueCommentPayload{- Event: &storepb.IssueCommentPayload_PlanUpdate_{- PlanUpdate: &storepb.IssueCommentPayload_PlanUpdate{- FromSpecs: oldPlan.Config.GetSpecs(),- ToSpecs: allSpecs,- },- },- },- })- }- issueToReset = issue- }default:return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update_mask path %q", path))}}- updatedPlan, err := s.store.UpdatePlan(ctx, planUpdate)- if err != nil {- if errors.Is(err, store.ErrPlanHasRollout) {- return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("cannot update specs for plan that has a rollout"))- }- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to update plan %q: %v", req.Plan.Name, err))- }-- resetApprovalFinding := func() *store.IssueMessage {- if issueToReset == nil {- return nil- }- updatedIssue, updated, err := resetIssueApprovalFindingIfPlanApprovalInputVersion(ctx, s.store, issueToReset, updatedPlan.Config.GetApprovalInputVersion())+ var updateResult *review.UpdatePlanSpecsResult+ var updatedPlan *store.PlanMessage+ if planCheckRunsTrigger {+ updateResult, err = s.reviewWorkflow.UpdatePlanSpecs(ctx, review.UpdatePlanSpecsInput{+ Workspace: common.GetWorkspaceIDFromContext(ctx),+ PlanUID: oldPlan.UID,+ ProjectID: oldPlan.ProjectID,+ Title: planUpdate.Name,+ Description: planUpdate.Description,+ Deleted: planUpdate.Deleted,+ Specs: specs,+ })if err != nil {- slog.Error("failed to reset approval finding status after plan update", log.BBError(err))- return nil+ var workflowErr *review.Error+ if errors.As(err, &workflowErr) && workflowErr.Code == review.ErrorFailedPrecondition {+ return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("cannot update specs for plan that has a rollout"))+ }+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to update plan %q: %v", req.Plan.Name, err))}- if !updated {- slog.Info("skip stale approval finding reset after plan update",- slog.String("project", issueToReset.ProjectID),- slog.Int64("issue_uid", issueToReset.UID),- slog.Int64("approval_input_version", updatedPlan.Config.GetApprovalInputVersion()))- return nil+ updatedPlan = updateResult.Plan+ } else {+ updatedPlan, err = s.store.UpdatePlan(ctx, planUpdate)+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to update plan %q: %v", req.Plan.Name, err))}- return updatedIssue+ updateResult = &review.UpdatePlanSpecsResult{Plan: updatedPlan}}var planCheckRunCreated boolif planCheckRunsTrigger {planCheckRun, err := getPlanCheckRunFromPlan(ctx, s.store, project, updatedPlan, databaseGroup)if err != nil {- resetApprovalFinding()return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get plan check run for plan"))}if planCheckRun != nil {created, err := s.store.CreatePlanCheckRun(ctx, planCheckRun)if err != nil {- resetApprovalFinding()return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create plan check run"))}planCheckRunCreated = created}}- if updatedIssue := resetApprovalFinding(); updatedIssue != nil {+ if updatedIssue := updateResult.Issue; updateResult.ApprovalReset && updatedIssue != nil {if updatedIssue.Type == storepb.Issue_DATABASE_EXPORT {- if err := approval.FindAndApplyApprovalTemplate(ctx, s.store, s.webhookManager, s.licenseService, updatedIssue); err != nil {+ approvalResult, err := review.FindAndApplyApprovalTemplate(ctx, s.store, s.licenseService, updatedIssue)+ if err != nil {slog.Error("failed to find approval template after plan update",slog.String("project", updatedIssue.ProjectID), slog.Int64("issue_uid", updatedIssue.UID),slog.String("issue_title", updatedIssue.Title),log.BBError(err))+ } else {+ review.DispatchApprovalEvents(ctx, s.store, s.webhookManager, approvalResult)}} else if updatedIssue.Type == storepb.Issue_DATABASE_CHANGE && planCheckRunsTrigger && !planCheckRunCreated {s.bus.ApprovalCheckChan <- bus.IssueRef{ProjectID: updatedIssue.ProjectID, UID: updatedIssue.UID}@@ -428,8 +400,23 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[vs.bus.PlanCheckTickleChan <- 0}- if len(issueCommentCreates) > 0 {- if _, err := s.store.CreateIssueComments(ctx, user.Email, issueCommentCreates...); err != nil {+ for _, event := range updateResult.Events {+ planUpdated, ok := event.(review.PlanUpdatedEvent)+ if !ok || updateResult.Issue == nil {+ continue+ }+ if _, err := s.store.CreateIssueComments(ctx, user.Email, &store.IssueCommentMessage{+ ProjectID: updateResult.Issue.ProjectID,+ IssueUID: updateResult.Issue.UID,+ Payload: &storepb.IssueCommentPayload{+ Event: &storepb.IssueCommentPayload_PlanUpdate_{+ PlanUpdate: &storepb.IssueCommentPayload_PlanUpdate{+ FromSpecs: planUpdated.FromSpecs,+ ToSpecs: planUpdated.ToSpecs,+ },+ },+ },+ }); err != nil {slog.Warn("failed to create plan spec audit issue comments", log.BBError(err))}}@@ -461,43 +448,6 @@ func (s *PlanService) GetPlanCheckRun(ctx context.Context, request *connect.Requreturn connect.NewResponse(converted), nil}-func resetIssueApprovalFindingIfPlanApprovalInputVersion(ctx context.Context, stores *store.Store, issue *store.IssueMessage, approvalInputVersion int64) (*store.IssueMessage, bool, error) {- if issue.Payload.GetDraft() {- return nil, false, nil- }-- payloadPatch := &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: approvalInputVersion,- },- }- if issue.Type == storepb.Issue_DATABASE_CHANGE {- // Plan check rows are visible before the reset finishes. If another worker already- // recomputed approval for this version, the reset must not move the issue back to CHECKING.- updatedIssue, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: payloadPatch,- RequirePlanApprovalInputVersion: &approvalInputVersion,- SkipIfCurrentApprovalFindingDone: &approvalInputVersion,- })- if err != nil {- if errors.Is(err, store.ErrIssueUpdateSkipped) {- return nil, false, nil- }- return nil, false, err- }- return updatedIssue, true, nil- }-- updatedIssue, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: payloadPatch,- })- if err != nil {- return nil, false, err- }- return updatedIssue, true, nil-}-// RunPlanChecks runs plan checks for a plan.func (s *PlanService) RunPlanChecks(ctx context.Context, request *connect.Request[v1pb.RunPlanChecksRequest]) (*connect.Response[v1pb.RunPlanChecksResponse], error) {req := request.Msg@@ -1180,26 +1130,6 @@ func convertToPlanSpecExportDataConfig(projectID string, config *storepb.PlanCon}}-// planSpecsEqualSet reports whether two spec slices have the same set of-// specs keyed by id, with each pair byte-equal under proto.Equal. Order-// is ignored — reorder-only diffs are not audited.-func planSpecsEqualSet(a, b []*storepb.PlanConfig_Spec) bool {- if len(a) != len(b) {- return false- }- byID := make(map[string]*storepb.PlanConfig_Spec, len(a))- for _, s := range a {- byID[s.GetId()] = s- }- for _, s := range b {- other, ok := byID[s.GetId()]- if !ok || !proto.Equal(s, other) {- return false- }- }- return true-}-func convertPlanSpecs(specs []*v1pb.Plan_Spec) []*storepb.PlanConfig_Spec {storeSpecs := make([]*storepb.PlanConfig_Spec, len(specs))for i := range specs {diff --git a/backend/api/v1/plan_service_test.go b/backend/api/v1/plan_service_test.goindex cfff2dc501..2264ffa6db 100644--- a/backend/api/v1/plan_service_test.go+++ b/backend/api/v1/plan_service_test.go@@ -6,7 +6,6 @@ import ("testing""connectrpc.com/connect"- "github.com/stretchr/testify/assert""github.com/stretchr/testify/require""github.com/bytebase/bytebase/backend/common"@@ -17,181 +16,6 @@ import ("github.com/bytebase/bytebase/backend/store")-func cdcSpec(id, sheet string, targets []string, priorBackup bool) *storepb.PlanConfig_Spec {- return &storepb.PlanConfig_Spec{- Id: id,- Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{- ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{- SheetSha256: sheet,- Targets: targets,- EnablePriorBackup: priorBackup,- },- },- }-}--func TestPlanSpecsEqualSet(t *testing.T) {- cases := []struct {- name string- a, b []*storepb.PlanConfig_Spec- want bool- }{- {- name: "both nil",- a: nil,- b: nil,- want: true,- },- {- name: "identical single spec",- a: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, false)},- b: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, false)},- want: true,- },- {- name: "same set reordered",- a: []*storepb.PlanConfig_Spec{- cdcSpec("s1", "sha1", []string{"db1"}, false),- cdcSpec("s2", "sha2", []string{"db2"}, false),- },- b: []*storepb.PlanConfig_Spec{- cdcSpec("s2", "sha2", []string{"db2"}, false),- cdcSpec("s1", "sha1", []string{"db1"}, false),- },- want: true,- },- {- name: "added spec",- a: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, false)},- b: []*storepb.PlanConfig_Spec{- cdcSpec("s1", "sha1", []string{"db1"}, false),- cdcSpec("s2", "sha2", []string{"db2"}, false),- },- want: false,- },- {- name: "removed spec",- a: []*storepb.PlanConfig_Spec{- cdcSpec("s1", "sha1", []string{"db1"}, false),- cdcSpec("s2", "sha2", []string{"db2"}, false),- },- b: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, false)},- want: false,- },- {- name: "same id sheet differs",- a: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, false)},- b: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha2", []string{"db1"}, false)},- want: false,- },- {- name: "same id targets differ",- a: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, false)},- b: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1", "db2"}, false)},- want: false,- },- {- name: "same id prior_backup differs",- a: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, false)},- b: []*storepb.PlanConfig_Spec{cdcSpec("s1", "sha1", []string{"db1"}, true)},- want: false,- },- }- for _, tc := range cases {- t.Run(tc.name, func(t *testing.T) {- assert.Equal(t, tc.want, planSpecsEqualSet(tc.a, tc.b))- })- }-}--func TestUpdateIssueApprovalResetSkipsStalePlanApprovalInputVersion(t *testing.T) {- ctx := context.Background()- s := setupPlanServiceTestStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 1,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedIssue, updated, err := resetIssueApprovalFindingIfPlanApprovalInputVersion(ctx, s, issue, 1)- require.NoError(t, err)- require.False(t, updated)- require.Nil(t, updatedIssue)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 1, got.Payload.GetApproval().GetApprovalInputVersion())-- updatedIssue, updated, err = resetIssueApprovalFindingIfPlanApprovalInputVersion(ctx, s, issue, 2)- require.NoError(t, err)- require.True(t, updated)- require.NotNil(t, updatedIssue)- require.False(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, updatedIssue.Payload.GetApproval().GetApprovalInputVersion())-}--func TestResetIssueApprovalFindingSkipsDraftIssue(t *testing.T) {- ctx := context.Background()- s := setupPlanServiceTestStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "draft issue",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Draft: true,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 1,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedIssue, updated, err := resetIssueApprovalFindingIfPlanApprovalInputVersion(ctx, s, issue, 2)- require.NoError(t, err)- require.False(t, updated)- require.Nil(t, updatedIssue)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.NotNil(t, got)- require.True(t, got.Payload.GetDraft())- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 1, got.Payload.GetApproval().GetApprovalInputVersion())-}-func TestPlanServiceListPlansKeepsIssueLessDraftsVisible(t *testing.T) {ctx := context.Background()stores := setupPlanServiceTestStore(ctx, t)diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.goindex 3bd6520311..b05d298a62 100644--- a/backend/api/v1/rollout_service.go+++ b/backend/api/v1/rollout_service.go@@ -12,7 +12,6 @@ import ("connectrpc.com/connect""github.com/jackc/pgtype""github.com/pkg/errors"- "google.golang.org/protobuf/proto""google.golang.org/protobuf/types/known/timestamppb""github.com/bytebase/bytebase/backend/common"@@ -22,6 +21,7 @@ import ("github.com/bytebase/bytebase/backend/component/dbfactory""github.com/bytebase/bytebase/backend/component/iam""github.com/bytebase/bytebase/backend/component/parsercontext"+ "github.com/bytebase/bytebase/backend/component/review""github.com/bytebase/bytebase/backend/component/webhook"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"@@ -415,42 +415,51 @@ func CreateRolloutAndPendingTasks(return errDraftIssueNotSubmitted}- var err error- if tasks == nil {- tasks, err = GetPipelineCreate(ctx, s, plan.Config.GetSpecs(), project.ResourceID)- if err != nil {- return errors.Wrap(err, "failed to get pipeline create for rollout creation")- }- }-- var issueApprovalGuard *store.IssueApprovalGuard- if issue != nil && issue.Type == storepb.Issue_DATABASE_CHANGE {- v := plan.Config.GetApprovalInputVersion()- issueApprovalGuard = &store.IssueApprovalGuard{ApprovalInputVersion: v}- if project.Setting.RequireIssueApproval {- var approval *storepb.IssuePayloadApproval- if sourceApproval := issue.Payload.GetApproval(); sourceApproval != nil {- approval = &storepb.IssuePayloadApproval{}- proto.Merge(approval, sourceApproval)+ result, err := review.NewWorkflow(s).CreateRollout(ctx, review.CreateRolloutInput{+ Workspace: project.Workspace,+ ProjectID: project.ResourceID,+ PlanUID: plan.UID,+ BuildTasks: func(ctx context.Context, currentPlan *store.PlanMessage, _ *store.ProjectMessage) ([]*store.TaskMessage, error) {+ if currentPlan.Config.GetApprovalInputVersion() != plan.Config.GetApprovalInputVersion() {+ return nil, errStaleRolloutApproval}- issueApprovalGuard.IssueUID = issue.UID- issueApprovalGuard.Approval = approval- }- }- marked, createdTasks, err := s.CreateRolloutTasks(ctx, project.ResourceID, plan.UID, issueApprovalGuard, tasks)+ if tasks != nil {+ return tasks, nil+ }+ created, err := GetPipelineCreate(ctx, s, currentPlan.Config.GetSpecs(), project.ResourceID)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get pipeline create for rollout creation")+ }+ return created, nil+ },+ })if err != nil {- if errors.Is(err, store.ErrDraftIssueNotSubmitted) {- return errDraftIssueNotSubmitted+ if errors.Is(err, errStaleRolloutApproval) {+ return errStaleRolloutApproval}- return errors.Wrap(err, "failed to create rollout tasks")- }- if !marked {- return errStaleRolloutApproval+ var workflowErr *review.Error+ if errors.As(err, &workflowErr) {+ switch workflowErr.Reason {+ case review.ReasonDraftIssue:+ return errDraftIssueNotSubmitted+ case review.ReasonApprovalRequired, review.ReasonStaleInput:+ return errStaleRolloutApproval+ default:+ }+ }+ return err}- tasks = createdTasks+ tasks = result.Tasks+ issue = result.Issue// Update issue status to DONE when rollout is created- if issue != nil {+ completeIssue := false+ for _, event := range result.Events {+ if _, ok := event.(review.CompleteRolloutIssueEvent); ok {+ completeIssue = true+ }+ }+ if issue != nil && completeIssue {newStatus := storepb.Issue_DONEupdatedIssue, err := s.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{Status: &newStatus})if err != nil {diff --git a/backend/component/parsercontext/parsercontext.go b/backend/component/parsercontext/parsercontext.goindex 1408a06348..6eac5e8831 100644--- a/backend/component/parsercontext/parsercontext.go+++ b/backend/component/parsercontext/parsercontext.go@@ -5,7 +5,7 @@// Lives outside the api/v1 package so both the api layer (e.g. sql_service,// release_service_check) and the runner layer (approval rule evaluation,// taskrun export executor) can use these without creating an import cycle-// — `api/v1` imports `runner/approval`, so `runner/approval` can't import+// — `api/v1` imports the review workflow, so the workflow can't import// from `api/v1` in return.package parsercontextdiff --git a/backend/component/review/approval.go b/backend/component/review/approval.gonew file mode 100644index 0000000000..cd20ac620c--- /dev/null+++ b/backend/component/review/approval.go@@ -0,0 +1,204 @@+package review++import (+ "context"+ "slices"++ "google.golang.org/protobuf/proto"++ "github.com/bytebase/bytebase/backend/enterprise"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++// ApprovalEvaluator owns license-dependent approval evaluation and its+// transactional commit through the review workflow.+type ApprovalEvaluator struct {+ workflow *Workflow+ licenseService *enterprise.LicenseService+ evaluateApproval func(context.Context, *store.IssueMessage, *store.ProjectMessage, *storepb.WorkspaceApprovalSetting) error+ approvalSetting *storepb.WorkspaceApprovalSetting+ beforeCommit func()+}++// NewApprovalEvaluator creates an approval evaluator with all production dependencies.+func NewApprovalEvaluator(store *store.Store, licenseService *enterprise.LicenseService) *ApprovalEvaluator {+ return &ApprovalEvaluator{+ workflow: NewWorkflow(store),+ licenseService: licenseService,+ }+}++// ApplyApprovalTemplateInput identifies a Bytebase Issue awaiting approval finding.+type ApplyApprovalTemplateInput struct {+ Workspace string+ ProjectID string+ IssueUID int64+}++// ApplyApprovalTemplateResult is the committed approval finding and its effects.+type ApplyApprovalTemplateResult struct {+ Issue *store.IssueMessage+ Project *store.ProjectMessage+ Applied bool+ Events []Event+}++// ApplyApprovalTemplate computes and commits an approval finding while keeping+// snapshot validation private to the module.+func (a *ApprovalEvaluator) ApplyApprovalTemplate(ctx context.Context, input ApplyApprovalTemplateInput) (*ApplyApprovalTemplateResult, error) {+ w := a.workflow+ project, err := w.store.GetProject(ctx, &store.FindProjectMessage{+ Workspace: input.Workspace,+ ResourceID: &input.ProjectID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get project")+ }+ if project == nil {+ return nil, workflowError(ErrorNotFound, "project %s not found", input.ProjectID)+ }+ issue, err := w.store.GetIssue(ctx, &store.FindIssueMessage{+ Workspace: input.Workspace,+ ProjectIDs: []string{input.ProjectID},+ UID: &input.IssueUID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get issue")+ }+ if issue == nil {+ return nil, workflowError(ErrorNotFound, "issue %d not found in project %s", input.IssueUID, input.ProjectID)+ }+ result := &ApplyApprovalTemplateResult{Issue: issue, Project: project}+ if issue.Payload.GetDraft() {+ return result, nil+ }++ var observedPlan *store.PlanMessage+ var observedPlanCheckRun *store.PlanCheckRunMessage+ var approvalInputVersion int64+ if issue.Type == storepb.Issue_DATABASE_CHANGE {+ if issue.PlanUID == nil {+ return nil, workflowError(ErrorFailedPrecondition, "expected plan UID in issue %d", issue.UID)+ }+ observedPlan, err = w.store.GetPlan(ctx, &store.FindPlanMessage{+ Workspace: input.Workspace,+ ProjectID: input.ProjectID,+ UID: issue.PlanUID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get plan")+ }+ if observedPlan == nil {+ return nil, workflowError(ErrorNotFound, "plan %d not found", *issue.PlanUID)+ }+ approvalInputVersion = observedPlan.Config.GetApprovalInputVersion()+ observedPlanCheckRun, err = w.store.GetPlanCheckRun(ctx, input.ProjectID, observedPlan.UID)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get Plan check generation")+ }+ }+ observedApproval := issue.Payload.GetApproval()+ if observedApproval != nil && observedApproval.GetApprovalFindingDone() && observedApproval.GetApprovalInputVersion() == approvalInputVersion {+ return result, nil+ }+ observedLabels := store.CanonicalizeIssueLabels(issue.Payload.GetLabels())+ evaluatedIssue := *issue+ evaluatedIssue.Payload = proto.CloneOf(issue.Payload)+ evaluate := a.evaluateApproval+ approvalSetting := a.approvalSetting+ if evaluate == nil {+ if a.licenseService == nil {+ return nil, workflowError(ErrorInternal, "approval evaluation is not configured")+ }+ if approvalSetting == nil {+ approvalSetting, err = w.store.GetWorkspaceApprovalSetting(ctx, project.Workspace)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get workspace approval setting")+ }+ }+ evaluate = func(ctx context.Context, issue *store.IssueMessage, project *store.ProjectMessage, setting *storepb.WorkspaceApprovalSetting) error {+ return evaluateApprovalTemplateForIssue(ctx, w.store, a.licenseService, issue, project, setting)+ }+ }+ if approvalSetting == nil {+ approvalSetting = &storepb.WorkspaceApprovalSetting{}+ }+ if err := evaluate(ctx, &evaluatedIssue, project, approvalSetting); err != nil {+ return nil, err+ }+ evaluatedApproval := evaluatedIssue.Payload.GetApproval()+ evaluatedRiskLevel := evaluatedIssue.Payload.GetRiskLevel()+ if approvalsEqual(evaluatedApproval, observedApproval) && evaluatedRiskLevel == issue.Payload.GetRiskLevel() {+ return result, nil+ }+ if evaluatedApproval == nil || evaluatedApproval.GetApprovalInputVersion() != approvalInputVersion {+ return nil, workflowError(ErrorConflict, "approval finding used stale input")+ }+ if a.beforeCommit != nil {+ a.beforeCommit()+ }++ tx, err := w.store.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to begin approval finding transaction")+ }+ defer tx.Rollback()+ lockedIssue, err := lockIssue(ctx, tx, input.ProjectID, input.IssueUID)+ if err != nil {+ return nil, err+ }+ if lockedIssue == nil {+ return nil, workflowError(ErrorNotFound, "issue %d not found in project %s", input.IssueUID, input.ProjectID)+ }+ lockedPlan, err := lockIssuePlan(ctx, tx, lockedIssue)+ if err != nil {+ return nil, err+ }+ if !approvalsEqual(lockedIssue.Payload.GetApproval(), observedApproval) ||+ !slices.Equal(store.CanonicalizeIssueLabels(lockedIssue.Payload.GetLabels()), observedLabels) ||+ lockedIssue.Payload.GetDraft() != issue.Payload.GetDraft() ||+ lockedIssue.Type != issue.Type ||+ !sameInt64Pointer(lockedIssue.PlanUID, issue.PlanUID) {+ return nil, workflowError(ErrorConflict, "approval finding input changed")+ }+ if observedPlan != nil && (lockedPlan == nil || lockedPlan.Config.GetApprovalInputVersion() != approvalInputVersion) {+ return nil, workflowError(ErrorConflict, "approval finding input changed")+ }+ if observedPlan != nil {+ generation, err := lockPlanCheckRunGeneration(ctx, tx, input.ProjectID, observedPlan.UID)+ if err != nil {+ return nil, err+ }+ if (generation == nil) != (observedPlanCheckRun == nil) ||+ generation != nil && *generation != observedPlanCheckRun.Generation {+ return nil, workflowError(ErrorConflict, "approval finding input changed")+ }+ }+ if lockedPlan != nil && project.Setting.GetRequireIssueApproval() && lockedPlan.Config.GetHasRollout() {+ return nil, workflowError(ErrorConflict, "rollout already started")+ }++ if err := updateIssuePayload(ctx, tx, lockedIssue, &storepb.Issue{+ Approval: evaluatedApproval,+ RiskLevel: evaluatedRiskLevel,+ }, false); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to apply approval finding")+ }+ lockedIssue.Payload.Approval = evaluatedApproval+ lockedIssue.Payload.RiskLevel = evaluatedRiskLevel+ if err := tx.Commit(); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to commit approval finding transaction")+ }+ result.Issue = lockedIssue+ result.Applied = true+ result.Events = []Event{ApprovalRequestedEvent{}}+ return result, nil+}++func approvalsEqual(a, b *storepb.IssuePayloadApproval) bool {+ if a == nil || b == nil {+ return a == nil && b == nil+ }+ return a.Equal(b)+}diff --git a/backend/runner/approval/runner.go b/backend/component/review/evaluator.gosimilarity index 88%rename from backend/runner/approval/runner.gorename to backend/component/review/evaluator.goindex 78b2548d8a..0fd665e9b1 100644--- a/backend/runner/approval/runner.go+++ b/backend/component/review/evaluator.go@@ -1,5 +1,4 @@-// Package approval is the runner for finding approval templates for issues.-package approval+package reviewimport ("context"@@ -66,29 +65,18 @@ func (r *Runner) Run(ctx context.Context, wg *sync.WaitGroup) {// FindAndApplyApprovalTemplate finds and applies the approval template for an issue.// This is a utility function that can be called synchronously (from issue creation)-// or asynchronously (from the event handler).-func FindAndApplyApprovalTemplate(ctx context.Context, stores *store.Store, webhookManager *webhook.Manager, licenseService *enterprise.LicenseService, issue *store.IssueMessage) error {+// or asynchronously (from the event handler). The caller dispatches returned+// events after the approval finding commits.+func FindAndApplyApprovalTemplate(ctx context.Context, stores *store.Store, licenseService *enterprise.LicenseService, issue *store.IssueMessage) (*ApplyApprovalTemplateResult, error) {if issue.Payload.GetDraft() {- return nil- }- project, err := stores.GetProjectByResourceID(ctx, issue.ProjectID)- if err != nil {- return errors.Wrap(err, "failed to get project")- }- if project == nil {- return errors.Errorf("project %s not found", issue.ProjectID)- }- approvalSetting, err := stores.GetWorkspaceApprovalSetting(ctx, project.Workspace)- if err != nil {- return errors.Wrap(err, "failed to get workspace approval setting")+ return &ApplyApprovalTemplateResult{Issue: issue}, nil}-// Find approval template - errors are logged, not persisted- err = findApprovalTemplateForIssue(ctx, stores, webhookManager, licenseService, issue, approvalSetting)+ result, err := findApprovalTemplateForIssue(ctx, stores, licenseService, issue)if err != nil {- return errors.Wrap(err, "failed to find approval template")+ return nil, errors.Wrap(err, "failed to find approval template")}- return nil+ return result, nil}func (r *Runner) processIssue(ctx context.Context, ref bus.IssueRef) {@@ -116,13 +104,8 @@ func (r *Runner) processIssue(ctx context.Context, ref bus.IssueRef) {slog.Error("project not found", slog.String("project", ref.ProjectID))return}- approvalSetting, err := r.store.GetWorkspaceApprovalSetting(ctx, project.Workspace)+ result, err := findApprovalTemplateForIssue(ctx, r.store, r.licenseService, issue)if err != nil {- slog.Error("failed to get workspace approval setting", log.BBError(err))- return- }-- if err := findApprovalTemplateForIssue(ctx, r.store, r.webhookManager, r.licenseService, issue, approvalSetting); err != nil {slog.Error("failed to find approval template",slog.String("project", ref.ProjectID), slog.Int64("issue_uid", ref.UID),slog.String("issue_title", issue.Title),@@ -130,6 +113,7 @@ func (r *Runner) processIssue(ctx context.Context, ref bus.IssueRef) {// Don't persist error - user can rerun plan check to retryreturn}+ DispatchApprovalEvents(ctx, r.store, r.webhookManager, result)// After approval finding is done, check if the issue is now approved// (e.g., skip approval case where no template is required).@@ -169,127 +153,6 @@ func (r *Runner) processIssue(ctx context.Context, ref bus.IssueRef) {}}-func findApprovalTemplateForIssue(ctx context.Context, stores *store.Store, webhookManager *webhook.Manager, licenseService *enterprise.LicenseService, issue *store.IssueMessage, approvalSetting *storepb.WorkspaceApprovalSetting) error {- if issue.Payload.GetDraft() {- return nil- }- payload := issue.Payload-- project, err := stores.GetProjectByResourceID(ctx, issue.ProjectID)- if err != nil {- return errors.Wrap(err, "failed to get project")- }- if project == nil {- return errors.Errorf("project %s not found", issue.ProjectID)- }-- approvalInputVersion, err := getIssuePlanApprovalInputVersion(ctx, stores, issue)- if err != nil {- return err- }- if payload.Approval != nil && payload.Approval.ApprovalFindingDone && payload.Approval.GetApprovalInputVersion() == approvalInputVersion {- return nil- }- approvalLabels := store.CanonicalizeIssueLabels(payload.GetLabels())- if approvalLabels == nil {- approvalLabels = []string{}- }-- approvalTemplate, celVarsList, approvalInputVersion, done, err := func() (*storepb.ApprovalTemplate, []map[string]any, int64, bool, error) {- // no need to find if feature is not enabled- if licenseService.IsFeatureEnabled(ctx, project.Workspace, v1pb.PlanFeature_FEATURE_APPROVAL_WORKFLOW) != nil {- // nolint:nilerr- return nil, nil, approvalInputVersion, true, nil- }-- // Step 1: Determine approval source from issue type- approvalSource, err := getApprovalSourceFromIssue(ctx, stores, issue)- if err != nil {- return nil, nil, approvalInputVersion, false, errors.Wrap(err, "failed to get approval source from issue")- }- if approvalSource == storepb.WorkspaceApprovalSetting_Rule_SOURCE_UNSPECIFIED {- // Cannot determine source, no approval needed- return nil, nil, approvalInputVersion, true, nil- }-- // Step 2: Build CEL variables for evaluation- celVarsList, celApprovalInputVersion, done, err := buildCELVariablesForIssue(ctx, stores, issue)- approvalInputVersion = celApprovalInputVersion- if err != nil {- return nil, nil, approvalInputVersion, false, errors.Wrap(err, "failed to build CEL variables for issue")- }- if !done {- // Not ready yet (e.g., waiting for plan check runs)- return nil, nil, approvalInputVersion, false, nil- }-- // Step 3: Inject risk level into CEL variables for CHANGE_DATABASE issues- // Risk level is calculated from statement types and injected so approval rules- // can use conditions like: risk_level == "HIGH"- if approvalSource == storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE {- riskLevel := calculateRiskLevelFromCELVars(celVarsList)- injectRiskLevelIntoCELVars(celVarsList, riskLevel)- injectIssueLabelsIntoCELVars(celVarsList, approvalLabels)- }-- // Step 4: Find matching approval template- approvalTemplate, err := getApprovalTemplate(approvalSetting, approvalSource, celVarsList)- if err != nil {- return nil, nil, approvalInputVersion, false, errors.Wrapf(err, "failed to get approval template for source: %v", approvalSource)- }-- return approvalTemplate, celVarsList, approvalInputVersion, true, nil- }()- if err != nil {- // Don't persist error - it will be logged by caller- // User can rerun plan check to retry- return err- }- if !done {- return nil- }-- // Calculate risk level separately from approval flow- // TODO(p0ny): maybe move risk calculation to another runner in the future- riskLevel := calculateRiskLevelFromCELVars(celVarsList)-- payload.Approval = &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalTemplate: approvalTemplate,- Approvers: nil,- ApprovalInputVersion: approvalInputVersion,- }- payload.RiskLevel = riskLevel-- payloadPatch := &storepb.Issue{- Approval: payload.Approval,- RiskLevel: riskLevel,- }- if issue.Type == storepb.Issue_DATABASE_CHANGE {- requireNoRollout := project.Setting.GetRequireIssueApproval()- _, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: payloadPatch,- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &approvalLabels,- RequireNoRollout: requireNoRollout,- })- if err != nil {- if errors.Is(err, store.ErrIssueUpdateSkipped) {- return nil- }- return errors.Wrap(err, "failed to update issue payload")- }- } else if _, err := stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: payloadPatch,- }); err != nil {- return errors.Wrap(err, "failed to update issue payload")- }-- NotifyApprovalRequested(ctx, stores, webhookManager, issue, project)-- return nil-}-func getIssuePlanApprovalInputVersion(ctx context.Context, stores *store.Store, issue *store.IssueMessage) (int64, error) {if issue.Type != storepb.Issue_DATABASE_CHANGE {return 0, nildiff --git a/backend/runner/approval/runner_test.go b/backend/component/review/evaluator_test.gosimilarity index 96%rename from backend/runner/approval/runner_test.gorename to backend/component/review/evaluator_test.goindex 73ddd382a9..de51c84a39 100644--- a/backend/runner/approval/runner_test.go+++ b/backend/component/review/evaluator_test.go@@ -1,4 +1,4 @@-package approval+package reviewimport ("context"@@ -519,6 +519,7 @@ func TestFindApprovalTemplateForIssueSkipsDatabaseChangeAfterRolloutWhenApprovalDescription: "",Config: &storepb.PlanConfig{ApprovalInputVersion: 2,+ HasRollout: true,Specs: []*storepb.PlanConfig_Spec{{Config: &storepb.PlanConfig_Spec_CreateDatabaseConfig{CreateDatabaseConfig: &storepb.PlanConfig_CreateDatabaseConfig{@@ -543,14 +544,9 @@ func TestFindApprovalTemplateForIssueSkipsDatabaseChangeAfterRolloutWhenApproval})require.NoError(t, err)- approvalInputVersion := int64(2)- marked, _, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)- require.NoError(t, err)- require.True(t, marked)-licenseService, err := enterprise.NewLicenseService(common.ReleaseModeDev, s, false, "")require.NoError(t, err)- err = findApprovalTemplateForIssue(ctx, s, nil, licenseService, issue, &storepb.WorkspaceApprovalSetting{})+ _, err = findApprovalTemplateForIssue(ctx, s, licenseService, issue, &storepb.WorkspaceApprovalSetting{})require.NoError(t, err)got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})@@ -569,6 +565,7 @@ func TestFindApprovalTemplateForIssueCompletesAfterRolloutWhenApprovalNotRequireDescription: "",Config: &storepb.PlanConfig{ApprovalInputVersion: 2,+ HasRollout: true,Specs: []*storepb.PlanConfig_Spec{{Config: &storepb.PlanConfig_Spec_CreateDatabaseConfig{CreateDatabaseConfig: &storepb.PlanConfig_CreateDatabaseConfig{@@ -593,14 +590,9 @@ func TestFindApprovalTemplateForIssueCompletesAfterRolloutWhenApprovalNotRequire})require.NoError(t, err)- approvalInputVersion := int64(2)- marked, _, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)- require.NoError(t, err)- require.True(t, marked)-licenseService, err := enterprise.NewLicenseService(common.ReleaseModeDev, s, false, "")require.NoError(t, err)- err = findApprovalTemplateForIssue(ctx, s, nil, licenseService, issue, &storepb.WorkspaceApprovalSetting{})+ _, err = findApprovalTemplateForIssue(ctx, s, licenseService, issue, &storepb.WorkspaceApprovalSetting{})require.NoError(t, err)got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})diff --git a/backend/component/review/finding.go b/backend/component/review/finding.gonew file mode 100644index 0000000000..d72b5170e1--- /dev/null+++ b/backend/component/review/finding.go@@ -0,0 +1,128 @@+package review++import (+ "context"++ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/component/webhook"+ "github.com/bytebase/bytebase/backend/enterprise"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+)++func findApprovalTemplateForIssue(ctx context.Context, stores *store.Store, licenseService *enterprise.LicenseService, issue *store.IssueMessage, settingForTest ...*storepb.WorkspaceApprovalSetting) (*ApplyApprovalTemplateResult, error) {+ project, err := stores.GetProjectByResourceID(ctx, issue.ProjectID)+ if err != nil {+ return nil, errors.Wrap(err, "failed to get project")+ }+ if project == nil {+ return nil, errors.Errorf("project %s not found", issue.ProjectID)+ }++ evaluator := NewApprovalEvaluator(stores, licenseService)+ if len(settingForTest) > 0 {+ evaluator.approvalSetting = settingForTest[0]+ }+ result, err := evaluator.ApplyApprovalTemplate(ctx, ApplyApprovalTemplateInput{+ Workspace: project.Workspace,+ ProjectID: issue.ProjectID,+ IssueUID: issue.UID,+ })+ if err != nil {+ var workflowErr *Error+ if errors.As(err, &workflowErr) && workflowErr.Code == ErrorConflict {+ return &ApplyApprovalTemplateResult{Issue: issue, Project: project}, nil+ }+ return nil, err+ }+ if !result.Applied {+ return result, nil+ }+ issue.Payload = result.Issue.Payload+ return result, nil+}++// DispatchApprovalEvents delivers post-commit effects from approval evaluation.+func DispatchApprovalEvents(ctx context.Context, stores *store.Store, webhookManager *webhook.Manager, result *ApplyApprovalTemplateResult) {+ if result == nil || result.Issue == nil || result.Project == nil {+ return+ }+ for _, event := range result.Events {+ if _, ok := event.(ApprovalRequestedEvent); ok {+ NotifyApprovalRequested(ctx, stores, webhookManager, result.Issue, result.Project)+ }+ }+}++func evaluateApprovalTemplateForIssue(+ ctx context.Context,+ stores *store.Store,+ licenseService *enterprise.LicenseService,+ issue *store.IssueMessage,+ project *store.ProjectMessage,+ approvalSetting *storepb.WorkspaceApprovalSetting,+) error {+ if issue.Payload.GetDraft() {+ return nil+ }+ approvalInputVersion, err := getIssuePlanApprovalInputVersion(ctx, stores, issue)+ if err != nil {+ return err+ }+ approvalLabels := store.CanonicalizeIssueLabels(issue.Payload.GetLabels())+ if approvalLabels == nil {+ approvalLabels = []string{}+ }++ approvalTemplate, celVarsList, approvalInputVersion, done, err := func() (*storepb.ApprovalTemplate, []map[string]any, int64, bool, error) {+ if licenseService.IsFeatureEnabled(ctx, project.Workspace, v1pb.PlanFeature_FEATURE_APPROVAL_WORKFLOW) != nil {+ // An unavailable approval-workflow feature intentionally falls back to no approval template.+ return nil, nil, approvalInputVersion, true, nil //nolint:nilerr+ }++ approvalSource, err := getApprovalSourceFromIssue(ctx, stores, issue)+ if err != nil {+ return nil, nil, approvalInputVersion, false, errors.Wrap(err, "failed to get approval source from issue")+ }+ if approvalSource == storepb.WorkspaceApprovalSetting_Rule_SOURCE_UNSPECIFIED {+ return nil, nil, approvalInputVersion, true, nil+ }++ celVarsList, celApprovalInputVersion, done, err := buildCELVariablesForIssue(ctx, stores, issue)+ approvalInputVersion = celApprovalInputVersion+ if err != nil {+ return nil, nil, approvalInputVersion, false, errors.Wrap(err, "failed to build CEL variables for issue")+ }+ if !done {+ return nil, nil, approvalInputVersion, false, nil+ }++ if approvalSource == storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE {+ riskLevel := calculateRiskLevelFromCELVars(celVarsList)+ injectRiskLevelIntoCELVars(celVarsList, riskLevel)+ injectIssueLabelsIntoCELVars(celVarsList, approvalLabels)+ }++ approvalTemplate, err := getApprovalTemplate(approvalSetting, approvalSource, celVarsList)+ if err != nil {+ return nil, nil, approvalInputVersion, false, errors.Wrapf(err, "failed to get approval template for source: %v", approvalSource)+ }+ return approvalTemplate, celVarsList, approvalInputVersion, true, nil+ }()+ if err != nil {+ return err+ }+ if !done {+ return nil+ }++ issue.Payload.Approval = &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalTemplate: approvalTemplate,+ ApprovalInputVersion: approvalInputVersion,+ }+ issue.Payload.RiskLevel = calculateRiskLevelFromCELVars(celVarsList)+ return nil+}diff --git a/backend/component/review/metadata.go b/backend/component/review/metadata.gonew file mode 100644index 0000000000..04c53331a2--- /dev/null+++ b/backend/component/review/metadata.go@@ -0,0 +1,138 @@+package review++import (+ "context"+ "slices"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++// UpdateIssueMetadataInput identifies a semantic Bytebase Issue metadata patch.+type UpdateIssueMetadataInput struct {+ Workspace string+ ProjectID string+ IssueUID int64++ Title *string+ Description *string+ Labels *[]string+}++// UpdateIssueMetadataResult is the committed metadata and review state.+type UpdateIssueMetadataResult struct {+ Issue *store.IssueMessage+ ApprovalReset bool+ Events []Event+}++// UpdateIssueMetadata updates Issue metadata and any required approval reset atomically.+func (w *Workflow) UpdateIssueMetadata(ctx context.Context, input UpdateIssueMetadataInput) (*UpdateIssueMetadataResult, error) {+ project, err := w.store.GetProject(ctx, &store.FindProjectMessage{+ Workspace: input.Workspace,+ ResourceID: &input.ProjectID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get project")+ }+ if project == nil {+ return nil, workflowError(ErrorNotFound, "project %s not found", input.ProjectID)+ }++ tx, err := w.store.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to begin issue metadata transaction")+ }+ defer tx.Rollback()+ issue, err := lockIssue(ctx, tx, input.ProjectID, input.IssueUID)+ if err != nil {+ return nil, err+ }+ if issue == nil {+ return nil, workflowError(ErrorNotFound, "issue %d not found in project %s", input.IssueUID, input.ProjectID)+ }+ result := &UpdateIssueMetadataResult{Issue: issue}+ patch := &store.UpdateIssueMessage{}+ if input.Title != nil && *input.Title != issue.Title {+ patch.Title = input.Title+ result.Events = append(result.Events, IssueTitleUpdatedEvent{FromTitle: issue.Title, ToTitle: *input.Title})+ }+ if input.Description != nil && *input.Description != issue.Description {+ patch.Description = input.Description+ result.Events = append(result.Events, IssueDescriptionUpdatedEvent{FromDescription: issue.Description, ToDescription: *input.Description})+ }++ var labels []string+ oldLabels := store.CanonicalizeIssueLabels(issue.Payload.GetLabels())+ labelsChanged := false+ if input.Labels != nil {+ labels = store.CanonicalizeIssueLabels(*input.Labels)+ labelsChanged = !slices.Equal(oldLabels, labels)+ }+ if !labelsChanged && patch.Title == nil && patch.Description == nil {+ if err := tx.Commit(); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to commit issue metadata transaction")+ }+ return result, nil+ }++ if labelsChanged {+ var plan *store.PlanMessage+ if !issue.Payload.GetDraft() && issue.Type == storepb.Issue_DATABASE_CHANGE && issue.PlanUID != nil {+ plan, err = lockIssuePlan(ctx, tx, issue)+ if err != nil {+ return nil, err+ }+ }+ resetApproval := shouldResetApprovalForLabels(issue, plan)+ payloadPatch := &storepb.Issue{Labels: labels}+ if resetApproval {+ payloadPatch.Approval = &storepb.IssuePayloadApproval{+ ApprovalInputVersion: plan.Config.GetApprovalInputVersion(),+ }+ result.ApprovalReset = true+ }+ patch.PayloadUpsert = payloadPatch+ patch.RemoveLabels = len(labels) == 0+ result.Events = append(result.Events, IssueLabelsUpdatedEvent{+ FromLabels: oldLabels,+ ToLabels: labels,+ })+ if resetApproval {+ result.Events = append(result.Events, ApprovalCheckEvent{})+ }+ }+ updatedAt, err := store.UpdateIssueTx(ctx, tx, issue, patch)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to update issue metadata")+ }+ issue.UpdatedAt = updatedAt+ if patch.Title != nil {+ issue.Title = *patch.Title+ }+ if patch.Description != nil {+ issue.Description = *patch.Description+ }+ if labelsChanged {+ issue.Payload.Labels = labels+ if result.ApprovalReset {+ issue.Payload.Approval = patch.PayloadUpsert.Approval+ }+ }+ if err := tx.Commit(); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to commit issue metadata transaction")+ }+ return result, nil+}++func shouldResetApprovalForLabels(issue *store.IssueMessage, plan *store.PlanMessage) bool {+ if issue.Payload.GetDraft() || issue.Type != storepb.Issue_DATABASE_CHANGE || plan == nil || plan.Config.GetHasRollout() {+ return false+ }+ for _, spec := range plan.Config.GetSpecs() {+ if _, ok := spec.Config.(*storepb.PlanConfig_Spec_ChangeDatabaseConfig); ok {+ return true+ }+ }+ return false+}diff --git a/backend/component/review/plan.go b/backend/component/review/plan.gonew file mode 100644index 0000000000..e581a821ca--- /dev/null+++ b/backend/component/review/plan.go@@ -0,0 +1,192 @@+package review++import (+ "context"+ "database/sql"+ "strconv"+ "time"++ "github.com/pkg/errors"+ "google.golang.org/protobuf/encoding/protojson"+ "google.golang.org/protobuf/proto"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++// UpdatePlanSpecsInput describes a review-affecting Plan spec mutation. Metadata+// is accepted only so a mixed API update remains atomic with the spec change.+type UpdatePlanSpecsInput struct {+ Workspace string+ ProjectID string+ PlanUID int64+ Title *string+ Description *string+ Deleted *bool+ Specs []*storepb.PlanConfig_Spec+}++// UpdatePlanSpecsResult is the committed Plan and linked review state.+type UpdatePlanSpecsResult struct {+ Plan *store.PlanMessage+ Issue *store.IssueMessage+ ApprovalReset bool+ Events []Event+}++// UpdatePlanSpecs commits a Plan spec mutation and any linked approval reset atomically.+func (w *Workflow) UpdatePlanSpecs(ctx context.Context, input UpdatePlanSpecsInput) (*UpdatePlanSpecsResult, error) {+ if w.beforePlanCommit != nil {+ w.beforePlanCommit()+ }+ tx, err := w.store.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to begin Plan review transaction")+ }+ defer tx.Rollback()++ key := input.ProjectID + "/" + strconv.FormatInt(input.PlanUID, 10)+ if err := store.AcquireAdvisoryXactLockWithStringKey(ctx, tx, store.AdvisoryLockKeyPlanIssueRollout, key); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to acquire Plan review lock")+ }+ issue, err := lockIssueByPlan(ctx, tx, input.ProjectID, input.PlanUID)+ if err != nil {+ return nil, err+ }+ plan, err := lockPlan(ctx, tx, input.Workspace, input.ProjectID, input.PlanUID)+ if err != nil {+ return nil, err+ }+ if plan == nil {+ return nil, workflowError(ErrorNotFound, "plan %d not found in project %s", input.PlanUID, input.ProjectID)+ }+ if plan.Config.GetHasRollout() {+ return nil, workflowError(ErrorFailedPrecondition, "cannot update specs for plan that has a rollout")+ }++ oldSpecs := plan.Config.GetSpecs()+ updatedConfig := proto.CloneOf(plan.Config)+ updatedConfig.Specs = input.Specs+ updatedConfig.ApprovalInputVersion = plan.Config.GetApprovalInputVersion() + 1+ config, err := protojson.Marshal(updatedConfig)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to marshal Plan config")+ }++ updatedAt := time.Now()+ if err := tx.QueryRowContext(ctx, `+ UPDATE plan+ SET updated_at = $1,+ name = CASE WHEN $2 THEN $3 ELSE name END,+ description = CASE WHEN $4 THEN $5 ELSE description END,+ deleted = CASE WHEN $6 THEN $7 ELSE deleted END,+ config = CASE WHEN $8 THEN $9::jsonb ELSE config END+ WHERE project = $10+ AND id = $11+ RETURNING updated_at`,+ updatedAt,+ input.Title != nil, stringValue(input.Title),+ input.Description != nil, stringValue(input.Description),+ input.Deleted != nil, boolValue(input.Deleted),+ true, config,+ input.ProjectID, input.PlanUID,+ ).Scan(&plan.UpdatedAt); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to update Plan")+ }+ if input.Title != nil {+ plan.Name = *input.Title+ }+ if input.Description != nil {+ plan.Description = *input.Description+ }+ if input.Deleted != nil {+ plan.Deleted = *input.Deleted+ }+ plan.Config = updatedConfig++ result := &UpdatePlanSpecsResult{Plan: plan, Issue: issue}+ if issue != nil && !issue.Payload.GetDraft() {+ approval := &storepb.IssuePayloadApproval{+ ApprovalFindingDone: false,+ ApprovalInputVersion: updatedConfig.GetApprovalInputVersion(),+ }+ if err := updateIssuePayload(ctx, tx, issue, &storepb.Issue{Approval: approval}, false); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to reset issue approval")+ }+ issue.Payload.Approval = approval+ result.ApprovalReset = true+ }+ if issue != nil && !planSpecsEqualSet(oldSpecs, input.Specs) {+ result.Events = append(result.Events, PlanUpdatedEvent{+ FromSpecs: oldSpecs,+ ToSpecs: input.Specs,+ })+ }++ if err := tx.Commit(); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to commit Plan review transaction")+ }+ return result, nil+}++func lockPlan(ctx context.Context, tx *sql.Tx, workspace, projectID string, planUID int64) (*store.PlanMessage, error) {+ plan := &store.PlanMessage{Config: &storepb.PlanConfig{}}+ var config []byte+ err := tx.QueryRowContext(ctx, `+ SELECT plan.id, plan.creator, plan.created_at, plan.updated_at, plan.project, plan.name, plan.description, plan.config, plan.deleted+ FROM plan+ JOIN project ON project.resource_id = plan.project+ WHERE project.workspace = $1+ AND plan.project = $2+ AND plan.id = $3+ FOR UPDATE OF plan`, workspace, projectID, planUID).Scan(+ &plan.UID,+ &plan.Creator,+ &plan.CreatedAt,+ &plan.UpdatedAt,+ &plan.ProjectID,+ &plan.Name,+ &plan.Description,+ &config,+ &plan.Deleted,+ )+ if errors.Is(err, sql.ErrNoRows) {+ return nil, nil+ }+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to lock Plan")+ }+ if err := common.ProtojsonUnmarshaler.Unmarshal(config, plan.Config); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to unmarshal Plan config")+ }+ return plan, nil+}++func planSpecsEqualSet(a, b []*storepb.PlanConfig_Spec) bool {+ if len(a) != len(b) {+ return false+ }+ byID := make(map[string]*storepb.PlanConfig_Spec, len(a))+ for _, spec := range a {+ byID[spec.GetId()] = spec+ }+ for _, spec := range b {+ other, ok := byID[spec.GetId()]+ if !ok || !proto.Equal(spec, other) {+ return false+ }+ }+ return true+}++func stringValue(value *string) string {+ if value == nil {+ return ""+ }+ return *value+}++func boolValue(value *bool) bool {+ return value != nil && *value+}diff --git a/backend/component/review/rollout.go b/backend/component/review/rollout.gonew file mode 100644index 0000000000..d6bb2fdf36--- /dev/null+++ b/backend/component/review/rollout.go@@ -0,0 +1,159 @@+package review++import (+ "context"+ "strconv"+ "time"++ "google.golang.org/protobuf/proto"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+ "github.com/bytebase/bytebase/backend/utils"+)++// CreateRolloutInput identifies a reviewed Plan ready for task creation.+type CreateRolloutInput struct {+ Workspace string+ ProjectID string+ PlanUID int64+ BuildTasks RolloutTaskBuilder+}++// RolloutTaskBuilder computes tasks from the workflow's current Plan snapshot.+type RolloutTaskBuilder func(context.Context, *store.PlanMessage, *store.ProjectMessage) ([]*store.TaskMessage, error)++// CreateRolloutResult is the committed rollout state and its follow-up effects.+type CreateRolloutResult struct {+ Plan *store.PlanMessage+ Issue *store.IssueMessage+ Project *store.ProjectMessage+ Tasks []*store.TaskMessage+ Events []Event+}++// CreateRollout validates current review state and atomically marks the Plan and creates tasks.+func (w *Workflow) CreateRollout(ctx context.Context, input CreateRolloutInput) (*CreateRolloutResult, error) {+ var project *store.ProjectMessage+ var err error+ if input.Workspace == "" {+ project, err = w.store.GetProjectByResourceID(ctx, input.ProjectID)+ } else {+ project, err = w.store.GetProject(ctx, &store.FindProjectMessage{+ Workspace: input.Workspace,+ ResourceID: &input.ProjectID,+ })+ }+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get project")+ }+ if project == nil {+ return nil, workflowError(ErrorNotFound, "project %s not found", input.ProjectID)+ }+ plan, err := w.store.GetPlan(ctx, &store.FindPlanMessage{+ Workspace: project.Workspace,+ ProjectID: input.ProjectID,+ UID: &input.PlanUID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get plan")+ }+ if plan == nil {+ return nil, workflowError(ErrorNotFound, "plan %d not found", input.PlanUID)+ }+ issue, err := w.store.GetIssue(ctx, &store.FindIssueMessage{+ Workspace: project.Workspace,+ ProjectIDs: []string{input.ProjectID},+ PlanUID: &input.PlanUID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get linked issue")+ }+ if issue != nil && issue.Payload.GetDraft() {+ return nil, workflowReasonError(ErrorFailedPrecondition, ReasonDraftIssue, "draft issue must be submitted before rollout creation")+ }+ if project.Setting.GetRequireIssueApproval() && issue != nil {+ approved, err := utils.CheckIssueApprovedForPlan(issue, plan)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to check issue approval")+ }+ if !approved {+ return nil, workflowReasonError(ErrorFailedPrecondition, ReasonApprovalRequired, "cannot create rollout because issue approval is required but the issue is not approved")+ }+ }+ if input.BuildTasks == nil {+ return nil, workflowError(ErrorInternal, "rollout task builder is required")+ }+ tasks, err := input.BuildTasks(ctx, plan, project)+ if err != nil {+ return nil, err+ }++ var observedApproval *storepb.IssuePayloadApproval+ if issue != nil {+ observedApproval = proto.CloneOf(issue.Payload.GetApproval())+ }++ tx, err := w.store.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to begin rollout transaction")+ }+ defer tx.Rollback()+ key := input.ProjectID + "/" + strconv.FormatInt(input.PlanUID, 10)+ if err := store.AcquireAdvisoryXactLockWithStringKey(ctx, tx, store.AdvisoryLockKeyPlanIssueRollout, key); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to acquire Plan review lock")+ }+ lockedIssue, err := lockIssueByPlan(ctx, tx, input.ProjectID, input.PlanUID)+ if err != nil {+ return nil, err+ }+ lockedPlan, err := lockPlan(ctx, tx, project.Workspace, input.ProjectID, input.PlanUID)+ if err != nil {+ return nil, err+ }+ if lockedPlan == nil {+ return nil, workflowError(ErrorNotFound, "plan %d not found", input.PlanUID)+ }+ if lockedPlan.Config.GetApprovalInputVersion() != plan.Config.GetApprovalInputVersion() {+ return nil, workflowReasonError(ErrorConflict, ReasonStaleInput, "issue approval is stale")+ }+ if lockedIssue != nil && lockedIssue.Payload.GetDraft() {+ return nil, workflowReasonError(ErrorFailedPrecondition, ReasonDraftIssue, "draft issue must be submitted before rollout creation")+ }+ if project.Setting.GetRequireIssueApproval() && lockedIssue != nil {+ if issue != nil && (lockedIssue.UID != issue.UID || !approvalsEqual(lockedIssue.Payload.GetApproval(), observedApproval)) {+ return nil, workflowReasonError(ErrorConflict, ReasonStaleInput, "issue approval is stale")+ }+ approved, err := utils.CheckIssueApprovedForPlan(lockedIssue, lockedPlan)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to check issue approval")+ }+ if !approved {+ return nil, workflowReasonError(ErrorFailedPrecondition, ReasonApprovalRequired, "cannot create rollout because issue approval is required but the issue is not approved")+ }+ }+ if !lockedPlan.Config.GetHasRollout() {+ if err := tx.QueryRowContext(ctx, `+ UPDATE plan+ SET updated_at = $1,+ config = jsonb_set(config, '{hasRollout}', 'true'::jsonb, true)+ WHERE project = $2+ AND id = $3+ RETURNING updated_at`, time.Now(), input.ProjectID, input.PlanUID).Scan(&lockedPlan.UpdatedAt); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to mark Plan has rollout")+ }+ lockedPlan.Config.HasRollout = true+ }+ tasks, err = w.store.CreateMissingTasksTx(ctx, tx, input.ProjectID, input.PlanUID, tasks)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to create rollout tasks")+ }+ if err := tx.Commit(); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to commit rollout transaction")+ }+ result := &CreateRolloutResult{Plan: lockedPlan, Issue: lockedIssue, Project: project, Tasks: tasks}+ if lockedIssue != nil {+ result.Events = []Event{CompleteRolloutIssueEvent{}}+ }+ return result, nil+}diff --git a/backend/component/review/rollout_test.go b/backend/component/review/rollout_test.gonew file mode 100644index 0000000000..25b6a3fcf7--- /dev/null+++ b/backend/component/review/rollout_test.go@@ -0,0 +1,60 @@+package review++import (+ "context"+ "testing"++ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+)++func TestCreateRolloutAddsMissingTasksAfterRolloutExists(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "plan-a",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 1},+ }, "[email protected]")+ require.NoError(t, err)+ workflow := NewWorkflow(stores)++ result, err := workflow.CreateRollout(ctx, CreateRolloutInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ BuildTasks: func(context.Context, *store.PlanMessage, *store.ProjectMessage) ([]*store.TaskMessage, error) {+ return []*store.TaskMessage{newRolloutReviewTask("database-a", "sheet-a")}, nil+ },+ })+ require.NoError(t, err)+ require.Len(t, result.Tasks, 1)++ result, err = workflow.CreateRollout(ctx, CreateRolloutInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ BuildTasks: func(context.Context, *store.PlanMessage, *store.ProjectMessage) ([]*store.TaskMessage, error) {+ return []*store.TaskMessage{+ newRolloutReviewTask("database-a", "sheet-a"),+ newRolloutReviewTask("database-b", "sheet-b"),+ }, nil+ },+ })+ require.NoError(t, err)+ require.Len(t, result.Tasks, 1)+ require.Equal(t, "database-b", result.Tasks[0].GetDatabaseName())+}++func newRolloutReviewTask(databaseName, sheetSHA256 string) *store.TaskMessage {+ return &store.TaskMessage{+ InstanceID: "instance-a",+ DatabaseName: &databaseName,+ Type: storepb.Task_DATABASE_MIGRATE,+ Payload: &storepb.Task{+ Source: &storepb.Task_SheetSha256{SheetSha256: sheetSHA256},+ },+ }+}diff --git a/backend/component/review/workflow.go b/backend/component/review/workflow.gonew file mode 100644index 0000000000..1be5687ace--- /dev/null+++ b/backend/component/review/workflow.go@@ -0,0 +1,523 @@+// Package review coordinates Bytebase Issue and Plan review transitions.+package review++import (+ "context"+ "database/sql"+ "log/slog"+ "time"++ "github.com/pkg/errors"+ "google.golang.org/protobuf/encoding/protojson"+ "google.golang.org/protobuf/proto"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/log"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/store"+ "github.com/bytebase/bytebase/backend/utils"+)++// ErrorCode classifies a rejected review transition.+type ErrorCode int++const (+ ErrorInternal ErrorCode = iota+ ErrorNotFound+ ErrorInvalidAction+ ErrorFailedPrecondition+ ErrorPermissionDenied+ ErrorConflict+)++// ErrorReason identifies a domain-specific reason within an error class.+type ErrorReason int++const (+ ReasonUnspecified ErrorReason = iota+ ReasonDraftIssue+ ReasonApprovalRequired+ ReasonStaleInput+)++// Error is a typed review transition error.+type Error struct {+ Code ErrorCode+ Reason ErrorReason+ Err error+}++func (e *Error) Error() string { return e.Err.Error() }+func (e *Error) Unwrap() error { return e.Err }++// Action is an interactive Bytebase Issue review action.+type Action int++const (+ ActionApprove Action = iota+ ActionReject+ ActionRequest+)++// Event describes a post-commit review effect.+type Event interface {+ isReviewEvent()+}++// IssueCommentEvent requests an approval timeline entry.+type IssueCommentEvent struct {+ ActorEmail string+ Comment string+ ApprovalStatus storepb.IssuePayloadApproval_Approver_Status+}++func (IssueCommentEvent) isReviewEvent() {}++// ApprovalRequestedEvent requests an approval notification.+type ApprovalRequestedEvent struct{}++func (ApprovalRequestedEvent) isReviewEvent() {}++// IssueApprovedEvent requests an approved notification.+type IssueApprovedEvent struct{}++func (IssueApprovedEvent) isReviewEvent() {}++// IssueSentBackEvent requests a sent-back notification.+type IssueSentBackEvent struct{}++func (IssueSentBackEvent) isReviewEvent() {}++// CompleteAccessRequestEvent requests access or role grant completion.+type CompleteAccessRequestEvent struct{}++func (CompleteAccessRequestEvent) isReviewEvent() {}++// CreateRolloutEvent requests rollout creation.+type CreateRolloutEvent struct{}++func (CreateRolloutEvent) isReviewEvent() {}++// PlanUpdatedEvent requests a Plan spec audit entry.+type PlanUpdatedEvent struct {+ FromSpecs []*storepb.PlanConfig_Spec+ ToSpecs []*storepb.PlanConfig_Spec+}++func (PlanUpdatedEvent) isReviewEvent() {}++// ApprovalCheckEvent requests approval reevaluation.+type ApprovalCheckEvent struct{}++func (ApprovalCheckEvent) isReviewEvent() {}++// IssueLabelsUpdatedEvent requests a label audit entry for the committed transition.+type IssueLabelsUpdatedEvent struct {+ FromLabels []string+ ToLabels []string+}++func (IssueLabelsUpdatedEvent) isReviewEvent() {}++// IssueTitleUpdatedEvent requests a title audit entry for the committed transition.+type IssueTitleUpdatedEvent struct {+ FromTitle string+ ToTitle string+}++func (IssueTitleUpdatedEvent) isReviewEvent() {}++// IssueDescriptionUpdatedEvent requests a description audit entry for the committed transition.+type IssueDescriptionUpdatedEvent struct {+ FromDescription string+ ToDescription string+}++func (IssueDescriptionUpdatedEvent) isReviewEvent() {}++// CompleteRolloutIssueEvent requests linked Bytebase Issue completion.+type CompleteRolloutIssueEvent struct{}++func (CompleteRolloutIssueEvent) isReviewEvent() {}++// IssueInput identifies an interactive review transition.+type IssueInput struct {+ Workspace string+ ProjectID string+ IssueUID int64+ Actor *store.UserMessage+ Action Action+ Comment string+}++// IssueResult is the committed state and its post-commit effects.+type IssueResult struct {+ Issue *store.IssueMessage+ Project *store.ProjectMessage+ Approved bool+ Events []Event+}++// Workflow owns transactional Bytebase Issue and Plan review transitions.+type Workflow struct {+ store *store.Store+ beforeCommit func()+ beforePlanCommit func()+}++// NewWorkflow creates a review workflow.+func NewWorkflow(store *store.Store) *Workflow {+ return &Workflow{store: store}+}++// ReviewIssue applies an interactive approval action atomically.+func (w *Workflow) ReviewIssue(ctx context.Context, input IssueInput) (*IssueResult, error) {+ if input.Actor == nil {+ return nil, workflowError(ErrorInternal, "user not found")+ }+ project, err := w.store.GetProject(ctx, &store.FindProjectMessage{+ Workspace: input.Workspace,+ ResourceID: &input.ProjectID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get project")+ }+ if project == nil {+ return nil, workflowError(ErrorNotFound, "project %s not found", input.ProjectID)+ }+ issue, err := w.store.GetIssue(ctx, &store.FindIssueMessage{+ Workspace: input.Workspace,+ ProjectIDs: []string{input.ProjectID},+ UID: &input.IssueUID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get issue")+ }+ if issue == nil {+ return nil, workflowError(ErrorNotFound, "issue %d not found in project %s", input.IssueUID, input.ProjectID)+ }+ if issue.Payload.GetDraft() {+ return nil, workflowError(ErrorFailedPrecondition, "draft issue must be submitted before approval actions are allowed")+ }+ approval := issue.Payload.GetApproval()+ if approval == nil {+ return nil, workflowError(ErrorInternal, "issue payload approval is nil")+ }+ if !approval.GetApprovalFindingDone() {+ return nil, workflowError(ErrorFailedPrecondition, "approval template finding is not done")+ }+ if approval.GetApprovalTemplate() == nil {+ return nil, workflowError(ErrorInternal, "approval template is required")+ }++ var observedPlan *store.PlanMessage+ if issue.Type == storepb.Issue_DATABASE_CHANGE && issue.PlanUID != nil {+ observedPlan, err = w.store.GetPlan(ctx, &store.FindPlanMessage{+ Workspace: input.Workspace,+ ProjectID: input.ProjectID,+ UID: issue.PlanUID,+ })+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to get plan")+ }+ if observedPlan == nil {+ return nil, workflowError(ErrorNotFound, "plan not found")+ }+ if approval.GetApprovalInputVersion() != observedPlan.Config.GetApprovalInputVersion() {+ return nil, workflowError(ErrorConflict, "approval finding is stale")+ }+ }++ updatedApproval := proto.CloneOf(approval)+ events, err := w.applyReviewAction(ctx, project, issue, input, updatedApproval)+ if err != nil {+ return nil, err+ }+ if w.beforeCommit != nil {+ w.beforeCommit()+ }++ tx, err := w.store.GetDB().BeginTx(ctx, nil)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to begin review transaction")+ }+ defer tx.Rollback()++ lockedIssue, err := lockIssue(ctx, tx, input.ProjectID, input.IssueUID)+ if err != nil {+ return nil, err+ }+ if lockedIssue == nil {+ return nil, workflowError(ErrorNotFound, "issue %d not found in project %s", input.IssueUID, input.ProjectID)+ }+ plan, err := lockIssuePlan(ctx, tx, lockedIssue)+ if err != nil {+ return nil, err+ }+ lockedApproval := lockedIssue.Payload.GetApproval()+ if lockedIssue.Payload.GetDraft() != issue.Payload.GetDraft() ||+ lockedIssue.Type != issue.Type ||+ !sameInt64Pointer(lockedIssue.PlanUID, issue.PlanUID) ||+ lockedApproval == nil || !lockedApproval.Equal(approval) {+ return nil, workflowError(ErrorConflict, "approval finding is stale")+ }+ if observedPlan != nil && (plan == nil || plan.Config.GetApprovalInputVersion() != observedPlan.Config.GetApprovalInputVersion()) {+ return nil, workflowError(ErrorConflict, "approval finding is stale")+ }++ if err := updateIssuePayload(ctx, tx, lockedIssue, &storepb.Issue{Approval: updatedApproval}, false); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to update issue approval")+ }+ lockedIssue.Payload.Approval = updatedApproval++ approved, err := utils.CheckIssueApprovedForPlan(lockedIssue, plan)+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to check if the issue is approved")+ }+ if err := tx.Commit(); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to commit review transaction")+ }+ if approved && input.Action == ActionApprove {+ events = append(events, IssueApprovedEvent{})+ switch lockedIssue.Type {+ case storepb.Issue_ACCESS_GRANT, storepb.Issue_ROLE_GRANT:+ events = append(events, CompleteAccessRequestEvent{})+ case storepb.Issue_DATABASE_CHANGE:+ if lockedIssue.PlanUID != nil {+ events = append(events, CreateRolloutEvent{})+ }+ default:+ }+ }++ return &IssueResult{+ Issue: lockedIssue,+ Project: project,+ Approved: approved,+ Events: events,+ }, nil+}++func updateIssuePayload(ctx context.Context, tx *sql.Tx, issue *store.IssueMessage, patch *storepb.Issue, removeLabels bool) error {+ payload, err := protojson.Marshal(patch)+ if err != nil {+ return errors.Wrap(err, "failed to marshal issue payload")+ }+ return tx.QueryRowContext(ctx, `+ UPDATE issue+ SET updated_at = $1,+ payload = payload || $2::jsonb || CASE WHEN $5 THEN jsonb_build_object('labels', NULL) ELSE '{}'::jsonb END+ WHERE project = $3+ AND id = $4+ RETURNING updated_at`,+ time.Now(), payload, issue.ProjectID, issue.UID, removeLabels,+ ).Scan(&issue.UpdatedAt)+}++func (w *Workflow) applyReviewAction(ctx context.Context, project *store.ProjectMessage, issue *store.IssueMessage, input IssueInput, approval *storepb.IssuePayloadApproval) ([]Event, error) {+ switch input.Action {+ case ActionApprove, ActionReject:+ verb := "approve"+ status := storepb.IssuePayloadApproval_Approver_APPROVED+ if input.Action == ActionReject {+ verb = "reject"+ status = storepb.IssuePayloadApproval_Approver_REJECTED+ }+ if utils.FindRejectedRole(approval) != "" {+ return nil, workflowError(ErrorInvalidAction, "cannot %s because the issue has been rejected", verb)+ }+ role := utils.FindNextPendingRole(approval)+ if role == "" {+ return nil, workflowError(ErrorInvalidAction, "the issue has been approved")+ }+ if !w.canReview(ctx, project, input.Actor, role) {+ return nil, workflowError(ErrorPermissionDenied, "cannot %s because the user does not have the required permission", verb)+ }+ if !project.Setting.GetAllowSelfApproval() && issue.CreatorEmail == input.Actor.Email {+ return nil, workflowError(ErrorPermissionDenied, "cannot %s because self-approval is not allowed for this project", verb)+ }+ approval.Approvers = append(approval.Approvers, &storepb.IssuePayloadApproval_Approver{+ Status: status,+ Principal: common.FormatUserEmail(input.Actor.Email),+ })+ events := []Event{IssueCommentEvent{+ ActorEmail: input.Actor.Email,+ Comment: input.Comment,+ ApprovalStatus: status,+ }}+ if input.Action == ActionApprove {+ events = append(events, ApprovalRequestedEvent{})+ } else {+ events = append(events, IssueSentBackEvent{})+ }+ return events, nil+ case ActionRequest:+ if utils.FindRejectedRole(approval) == "" {+ return nil, workflowError(ErrorInvalidAction, "cannot request issues because the issue is not rejected")+ }+ if issue.CreatorEmail != input.Actor.Email {+ return nil, workflowError(ErrorPermissionDenied, "cannot request issues because you are not the issue creator")+ }++ approvers := approval.Approvers[:0]+ for _, approver := range approval.Approvers {+ if approver.Status != storepb.IssuePayloadApproval_Approver_REJECTED {+ approvers = append(approvers, approver)+ }+ }+ approval.Approvers = approvers+ return []Event{+ ApprovalRequestedEvent{},+ IssueCommentEvent{+ ActorEmail: input.Actor.Email,+ Comment: input.Comment,+ ApprovalStatus: storepb.IssuePayloadApproval_Approver_PENDING,+ },+ }, nil+ default:+ return nil, workflowError(ErrorInvalidAction, "unsupported review action")+ }+}++func (w *Workflow) canReview(ctx context.Context, project *store.ProjectMessage, user *store.UserMessage, role string) bool {+ projectPolicy, err := w.store.GetProjectIamPolicy(ctx, project.Workspace, project.ResourceID)+ if err != nil {+ slog.Warn("failed to get project IAM policy", slog.String("project", project.ResourceID), log.BBError(err))+ return false+ }+ workspacePolicy, err := w.store.GetWorkspaceIamPolicy(ctx, project.Workspace)+ if err != nil {+ slog.Warn("failed to get workspace IAM policy", slog.String("workspace", project.Workspace), log.BBError(err))+ return false+ }+ roles := utils.GetUserFormattedRolesMap(ctx, w.store, project.Workspace, user, projectPolicy.Policy, workspacePolicy.Policy)+ return roles[role]+}++func lockIssue(ctx context.Context, tx *sql.Tx, projectID string, issueUID int64) (*store.IssueMessage, error) {+ return scanLockedIssue(tx.QueryRowContext(ctx, `+ SELECT id, creator, created_at, updated_at, project, plan_id, name, status, type, description, payload+ FROM issue+ WHERE project = $1+ AND id = $2+ FOR UPDATE`, projectID, issueUID))+}++func lockIssueByPlan(ctx context.Context, tx *sql.Tx, projectID string, planUID int64) (*store.IssueMessage, error) {+ return scanLockedIssue(tx.QueryRowContext(ctx, `+ SELECT id, creator, created_at, updated_at, project, plan_id, name, status, type, description, payload+ FROM issue+ WHERE project = $1+ AND plan_id = $2+ FOR UPDATE`, projectID, planUID))+}++func scanLockedIssue(row *sql.Row) (*store.IssueMessage, error) {+ issue := &store.IssueMessage{Payload: &storepb.Issue{}}+ var payload []byte+ var status string+ var issueType string+ err := row.Scan(+ &issue.UID,+ &issue.CreatorEmail,+ &issue.CreatedAt,+ &issue.UpdatedAt,+ &issue.ProjectID,+ &issue.PlanUID,+ &issue.Title,+ &status,+ &issueType,+ &issue.Description,+ &payload,+ )+ if errors.Is(err, sql.ErrNoRows) {+ return nil, nil+ }+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to lock issue")+ }+ statusValue, ok := storepb.Issue_Status_value[status]+ if !ok {+ return nil, workflowError(ErrorInternal, "invalid issue status %q", status)+ }+ issue.Status = storepb.Issue_Status(statusValue)+ typeValue, ok := storepb.Issue_Type_value[issueType]+ if !ok {+ return nil, workflowError(ErrorInternal, "invalid issue type %q", issueType)+ }+ issue.Type = storepb.Issue_Type(typeValue)+ if err := common.ProtojsonUnmarshaler.Unmarshal(payload, issue.Payload); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to unmarshal issue payload")+ }+ return issue, nil+}++func lockIssuePlan(ctx context.Context, tx *sql.Tx, issue *store.IssueMessage) (*store.PlanMessage, error) {+ if issue.Type != storepb.Issue_DATABASE_CHANGE || issue.PlanUID == nil {+ return nil, nil+ }+ plan := &store.PlanMessage{Config: &storepb.PlanConfig{}}+ var config []byte+ err := tx.QueryRowContext(ctx, `+ SELECT id, creator, created_at, updated_at, project, name, description, config, deleted+ FROM plan+ WHERE project = $1+ AND id = $2+ FOR UPDATE`, issue.ProjectID, *issue.PlanUID).Scan(+ &plan.UID,+ &plan.Creator,+ &plan.CreatedAt,+ &plan.UpdatedAt,+ &plan.ProjectID,+ &plan.Name,+ &plan.Description,+ &config,+ &plan.Deleted,+ )+ if errors.Is(err, sql.ErrNoRows) {+ return nil, workflowError(ErrorNotFound, "plan not found")+ }+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to lock plan")+ }+ if err := common.ProtojsonUnmarshaler.Unmarshal(config, plan.Config); err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to unmarshal plan config")+ }+ return plan, nil+}++func lockPlanCheckRunGeneration(ctx context.Context, tx *sql.Tx, projectID string, planUID int64) (*int64, error) {+ var generation int64+ err := tx.QueryRowContext(ctx, `+ SELECT xmin::text::bigint+ FROM plan_check_run+ WHERE project = $1+ AND plan_id = $2+ FOR UPDATE`, projectID, planUID).Scan(&generation)+ if errors.Is(err, sql.ErrNoRows) {+ return nil, nil+ }+ if err != nil {+ return nil, workflowWrap(ErrorInternal, err, "failed to lock Plan check generation")+ }+ return &generation, nil+}++func workflowError(code ErrorCode, format string, args ...any) error {+ return &Error{Code: code, Err: errors.Errorf(format, args...)}+}++func workflowReasonError(code ErrorCode, reason ErrorReason, message string) error {+ return &Error{Code: code, Reason: reason, Err: errors.New(message)}+}++func workflowWrap(_ ErrorCode, err error, message string) error {+ return &Error{Code: ErrorInternal, Err: errors.Wrap(err, message)}+}++func sameInt64Pointer(a, b *int64) bool {+ if a == nil || b == nil {+ return a == nil && b == nil+ }+ return *a == *b+}diff --git a/backend/component/review/workflow_test.go b/backend/component/review/workflow_test.gonew file mode 100644index 0000000000..ffaa406d3c--- /dev/null+++ b/backend/component/review/workflow_test.go@@ -0,0 +1,981 @@+package review++import (+ "context"+ "errors"+ "fmt"+ "sync"+ "testing"+ "time"++ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/testcontainer"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/migrator"+ "github.com/bytebase/bytebase/backend/store"+)++func TestReviewIssueRequestAgain(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)++ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "request access",+ Type: storepb.Issue_ROLE_GRANT,+ Payload: &storepb.Issue{+ Approval: &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalTemplate: &storepb.ApprovalTemplate{+ Flow: &storepb.ApprovalFlow{Roles: []string{"roles/projectOwner"}},+ },+ Approvers: []*storepb.IssuePayloadApproval_Approver{{+ Status: storepb.IssuePayloadApproval_Approver_REJECTED,+ Principal: common.FormatUserEmail("[email protected]"),+ }},+ },+ },+ })+ require.NoError(t, err)++ result, err := NewWorkflow(stores).ReviewIssue(ctx, IssueInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Actor: &store.UserMessage{Email: "[email protected]"},+ Action: ActionRequest,+ Comment: "addressed",+ })+ require.NoError(t, err)+ require.Empty(t, result.Issue.Payload.GetApproval().GetApprovers())+ require.Equal(t, []Event{+ ApprovalRequestedEvent{},+ IssueCommentEvent{+ ActorEmail: "[email protected]",+ Comment: "addressed",+ ApprovalStatus: storepb.IssuePayloadApproval_Approver_PENDING,+ },+ }, result.Events)+}++func TestReviewIssueApproveCurrentPlan(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ _, err := stores.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{+ Workspace: "default",+ Member: common.FormatUserEmail("[email protected]"),+ Roles: []string{"roles/projectOwner"},+ })+ require.NoError(t, err)++ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 2},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Approval: &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ ApprovalTemplate: &storepb.ApprovalTemplate{+ Flow: &storepb.ApprovalFlow{Roles: []string{"roles/projectOwner"}},+ },+ },+ },+ })+ require.NoError(t, err)++ result, err := NewWorkflow(stores).ReviewIssue(ctx, IssueInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Actor: &store.UserMessage{Email: "[email protected]"},+ Action: ActionApprove,+ Comment: "looks good",+ })+ require.NoError(t, err)+ require.True(t, result.Approved)+ require.Len(t, result.Issue.Payload.GetApproval().GetApprovers(), 1)+ require.True(t, proto.Equal(&storepb.IssuePayloadApproval_Approver{+ Status: storepb.IssuePayloadApproval_Approver_APPROVED,+ Principal: common.FormatUserEmail("[email protected]"),+ }, result.Issue.Payload.GetApproval().GetApprovers()[0]))+ require.Equal(t, []Event{+ IssueCommentEvent{+ ActorEmail: "[email protected]",+ Comment: "looks good",+ ApprovalStatus: storepb.IssuePayloadApproval_Approver_APPROVED,+ },+ ApprovalRequestedEvent{},+ IssueApprovedEvent{},+ CreateRolloutEvent{},+ }, result.Events)+}++func TestReviewIssueConcurrentApprovalsHaveOneWinner(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ for _, email := range []string{"[email protected]", "[email protected]"} {+ _, err := stores.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{+ Workspace: "default",+ Member: common.FormatUserEmail(email),+ Roles: []string{"roles/projectOwner"},+ })+ require.NoError(t, err)+ }+ _, issue := createPendingDatabaseChangeApproval(ctx, t, stores, []string{"roles/projectOwner", "roles/projectOwner"})+ workflow := NewWorkflow(stores)+ var proposals sync.WaitGroup+ proposals.Add(2)+ releaseCommit := make(chan struct{})+ workflow.beforeCommit = func() {+ proposals.Done()+ <-releaseCommit+ }++ type outcome struct {+ result *IssueResult+ err error+ }+ outcomes := make(chan outcome, 2)+ start := make(chan struct{})+ var wg sync.WaitGroup+ for _, email := range []string{"[email protected]", "[email protected]"} {+ wg.Go(func() {+ <-start+ result, err := workflow.ReviewIssue(ctx, IssueInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Actor: &store.UserMessage{Email: email},+ Action: ActionApprove,+ })+ outcomes <- outcome{result: result, err: err}+ })+ }+ close(start)+ proposals.Wait()+ close(releaseCommit)+ wg.Wait()+ close(outcomes)++ var succeeded, rejected int+ for outcome := range outcomes {+ if outcome.err == nil {+ succeeded+++ require.False(t, outcome.result.Approved)+ require.Len(t, outcome.result.Events, 2)+ continue+ }+ var workflowErr *Error+ require.True(t, errors.As(outcome.err, &workflowErr))+ require.Equal(t, ErrorConflict, workflowErr.Code)+ require.Empty(t, outcome.result)+ rejected+++ }+ require.Equal(t, 1, succeeded)+ require.Equal(t, 1, rejected)+}++func TestPlanUpdateMakesPendingApprovalActionStale(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ _, err := stores.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{+ Workspace: "default",+ Member: common.FormatUserEmail("[email protected]"),+ Roles: []string{"roles/projectOwner"},+ })+ require.NoError(t, err)+ plan, issue := createPendingDatabaseChangeApproval(ctx, t, stores, []string{"roles/projectOwner"})+ workflow := NewWorkflow(stores)+ proposalReady := make(chan struct{})+ releaseCommit := make(chan struct{})+ workflow.beforeCommit = func() {+ close(proposalReady)+ <-releaseCommit+ }++ actionDone := make(chan error, 1)+ go func() {+ _, err := workflow.ReviewIssue(ctx, IssueInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Actor: &store.UserMessage{Email: "[email protected]"},+ Action: ActionApprove,+ })+ actionDone <- err+ }()+ <-proposalReady++ planResult, err := workflow.UpdatePlanSpecs(ctx, UpdatePlanSpecsInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Specs: []*storepb.PlanConfig_Spec{{Id: "new"}},+ })+ require.NoError(t, err)+ require.True(t, planResult.ApprovalReset)+ close(releaseCommit)++ err = <-actionDone+ var workflowErr *Error+ require.True(t, errors.As(err, &workflowErr))+ require.Equal(t, ErrorConflict, workflowErr.Code)+ require.False(t, planResult.Issue.Payload.GetApproval().GetApprovalFindingDone())+ require.EqualValues(t, 3, planResult.Issue.Payload.GetApproval().GetApprovalInputVersion())+}++func TestUpdatePlanResetsLinkedIssueApprovalAtomically(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ oldSpecs := []*storepb.PlanConfig_Spec{{Id: "old"}}+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{+ ApprovalInputVersion: 2,+ Specs: oldSpecs,+ },+ }, "[email protected]")+ require.NoError(t, err)+ _, err = stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Approval: &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ ApprovalTemplate: &storepb.ApprovalTemplate{+ Flow: &storepb.ApprovalFlow{Roles: []string{"roles/projectOwner"}},+ },+ },+ },+ })+ require.NoError(t, err)+ newSpecs := []*storepb.PlanConfig_Spec{{Id: "new"}}++ result, err := NewWorkflow(stores).UpdatePlanSpecs(ctx, UpdatePlanSpecsInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Specs: newSpecs,+ })+ require.NoError(t, err)+ require.EqualValues(t, 3, result.Plan.Config.GetApprovalInputVersion())+ require.Equal(t, newSpecs, result.Plan.Config.GetSpecs())+ require.True(t, result.ApprovalReset)+ require.False(t, result.Issue.Payload.GetApproval().GetApprovalFindingDone())+ require.EqualValues(t, 3, result.Issue.Payload.GetApproval().GetApprovalInputVersion())+ require.Equal(t, []Event{PlanUpdatedEvent{+ FromSpecs: oldSpecs,+ ToSpecs: newSpecs,+ }}, result.Events)+}++func TestUpdatePlanSpecsIncludesIssueLinkedAfterProposal(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{+ ApprovalInputVersion: 2,+ Specs: []*storepb.PlanConfig_Spec{{Id: "old"}},+ },+ }, "[email protected]")+ require.NoError(t, err)++ workflow := NewWorkflow(stores)+ proposalReady := make(chan struct{})+ releaseCommit := make(chan struct{})+ workflow.beforePlanCommit = func() {+ close(proposalReady)+ <-releaseCommit+ }+ type updateOutcome struct {+ result *UpdatePlanSpecsResult+ err error+ }+ updateDone := make(chan updateOutcome, 1)+ go func() {+ result, err := workflow.UpdatePlanSpecs(ctx, UpdatePlanSpecsInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Specs: []*storepb.PlanConfig_Spec{{Id: "new"}},+ })+ updateDone <- updateOutcome{result: result, err: err}+ }()++ select {+ case <-proposalReady:+ case <-time.After(5 * time.Second):+ t.Fatal("Plan update did not reach the commit seam")+ }+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{Approval: &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ }},+ })+ require.NoError(t, err)+ close(releaseCommit)++ outcome := <-updateDone+ require.NoError(t, outcome.err)+ require.NotNil(t, outcome.result.Issue)+ require.Equal(t, issue.UID, outcome.result.Issue.UID)+ require.True(t, outcome.result.ApprovalReset)+ require.False(t, outcome.result.Issue.Payload.GetApproval().GetApprovalFindingDone())+ require.EqualValues(t, 3, outcome.result.Issue.Payload.GetApproval().GetApprovalInputVersion())+}++func TestApplyApprovalTemplateCommitsFindingAndIntent(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 2},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Labels: []string{"environment:prod"},+ Approval: &storepb.IssuePayloadApproval{+ ApprovalInputVersion: 2,+ },+ },+ })+ require.NoError(t, err)+ finding := &storepb.Issue{+ Approval: &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ ApprovalTemplate: &storepb.ApprovalTemplate{+ Flow: &storepb.ApprovalFlow{Roles: []string{"roles/projectOwner"}},+ },+ },+ RiskLevel: storepb.RiskLevel_HIGH,+ }++ evaluator := &ApprovalEvaluator{workflow: NewWorkflow(stores)}+ evaluator.evaluateApproval = func(_ context.Context, issue *store.IssueMessage, _ *store.ProjectMessage, _ *storepb.WorkspaceApprovalSetting) error {+ issue.Payload.Approval = finding.Approval+ issue.Payload.RiskLevel = finding.RiskLevel+ return nil+ }+ result, err := evaluator.ApplyApprovalTemplate(ctx, ApplyApprovalTemplateInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ })+ require.NoError(t, err)+ require.True(t, result.Applied)+ require.True(t, result.Issue.Payload.GetApproval().Equal(finding.Approval))+ require.Equal(t, storepb.RiskLevel_HIGH, result.Issue.Payload.GetRiskLevel())+ require.Equal(t, []Event{ApprovalRequestedEvent{}}, result.Events)+}++func TestPlanCheckRerunMakesPendingApprovalFindingStale(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 2},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{Approval: &storepb.IssuePayloadApproval{+ ApprovalInputVersion: 2,+ }},+ })+ require.NoError(t, err)+ created, err := stores.CreatePlanCheckRun(ctx, &store.PlanCheckRunMessage{+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Result: &storepb.PlanCheckRunResult{ApprovalInputVersion: 2},+ })+ require.NoError(t, err)+ require.True(t, created)+ planCheckRun, err := stores.GetPlanCheckRun(ctx, "project-a", plan.UID)+ require.NoError(t, err)+ require.NoError(t, stores.UpdatePlanCheckRun(ctx, "project-a", store.PlanCheckRunStatusDone, &storepb.PlanCheckRunResult{+ ApprovalInputVersion: 2,+ }, planCheckRun.UID))++ evaluator := &ApprovalEvaluator{workflow: NewWorkflow(stores)}+ evaluator.evaluateApproval = func(_ context.Context, issue *store.IssueMessage, _ *store.ProjectMessage, _ *storepb.WorkspaceApprovalSetting) error {+ issue.Payload.Approval = &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ }+ return nil+ }+ proposalReady := make(chan struct{})+ releaseCommit := make(chan struct{})+ evaluator.beforeCommit = func() {+ close(proposalReady)+ <-releaseCommit+ }+ type findingOutcome struct {+ result *ApplyApprovalTemplateResult+ err error+ }+ applyDone := make(chan findingOutcome, 1)+ go func() {+ result, err := evaluator.ApplyApprovalTemplate(ctx, ApplyApprovalTemplateInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ })+ applyDone <- findingOutcome{result: result, err: err}+ }()+ <-proposalReady++ refreshed, err := stores.CreatePlanCheckRun(ctx, &store.PlanCheckRunMessage{+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Result: &storepb.PlanCheckRunResult{ApprovalInputVersion: 2},+ })+ require.NoError(t, err)+ require.True(t, refreshed)+ close(releaseCommit)++ finding := <-applyDone+ require.Nil(t, finding.result)+ var workflowErr *Error+ require.ErrorAs(t, finding.err, &workflowErr)+ require.Equal(t, ErrorConflict, workflowErr.Code)+ got, err := stores.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})+ require.NoError(t, err)+ require.False(t, got.Payload.GetApproval().GetApprovalFindingDone())+}++func TestPlanCheckCreatedDuringApprovalMakesPendingFindingStale(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 2},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{Approval: &storepb.IssuePayloadApproval{+ ApprovalInputVersion: 2,+ }},+ })+ require.NoError(t, err)++ evaluator := &ApprovalEvaluator{workflow: NewWorkflow(stores)}+ evaluator.evaluateApproval = func(_ context.Context, issue *store.IssueMessage, _ *store.ProjectMessage, _ *storepb.WorkspaceApprovalSetting) error {+ created, err := stores.CreatePlanCheckRun(ctx, &store.PlanCheckRunMessage{+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Result: &storepb.PlanCheckRunResult{ApprovalInputVersion: 2},+ })+ require.NoError(t, err)+ require.True(t, created)+ planCheckRun, err := stores.GetPlanCheckRun(ctx, "project-a", plan.UID)+ require.NoError(t, err)+ require.NoError(t, stores.UpdatePlanCheckRun(ctx, "project-a", store.PlanCheckRunStatusDone, &storepb.PlanCheckRunResult{+ ApprovalInputVersion: 2,+ }, planCheckRun.UID))+ issue.Payload.Approval = &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ }+ return nil+ }+ evaluator.beforeCommit = func() {+ refreshed, err := stores.CreatePlanCheckRun(ctx, &store.PlanCheckRunMessage{+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Result: &storepb.PlanCheckRunResult{ApprovalInputVersion: 2},+ })+ require.NoError(t, err)+ require.True(t, refreshed)+ }++ result, err := evaluator.ApplyApprovalTemplate(ctx, ApplyApprovalTemplateInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ })+ require.Nil(t, result)+ var workflowErr *Error+ require.ErrorAs(t, err, &workflowErr)+ require.Equal(t, ErrorConflict, workflowErr.Code)+ got, err := stores.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})+ require.NoError(t, err)+ require.False(t, got.Payload.GetApproval().GetApprovalFindingDone())+}++func TestUpdateIssueMetadataCommitsMixedPatchAndResetsApproval(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{+ ApprovalInputVersion: 2,+ Specs: []*storepb.PlanConfig_Spec{{+ Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{+ ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{},+ },+ }},+ },+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Description: "old description",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Labels: []string{"old"},+ Approval: &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ },+ },+ })+ require.NoError(t, err)++ title := "renamed database change"+ description := ""+ labels := []string{"new"}+ result, err := NewWorkflow(stores).UpdateIssueMetadata(ctx, UpdateIssueMetadataInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Title: &title,+ Description: &description,+ Labels: &labels,+ })+ require.NoError(t, err)+ require.Equal(t, title, result.Issue.Title)+ require.Empty(t, result.Issue.Description)+ require.Equal(t, []string{"new"}, result.Issue.Payload.GetLabels())+ require.True(t, result.ApprovalReset)+ require.False(t, result.Issue.Payload.GetApproval().GetApprovalFindingDone())+ require.EqualValues(t, 2, result.Issue.Payload.GetApproval().GetApprovalInputVersion())+ require.Equal(t, []Event{+ IssueTitleUpdatedEvent{FromTitle: "change database", ToTitle: title},+ IssueDescriptionUpdatedEvent{FromDescription: "old description", ToDescription: ""},+ IssueLabelsUpdatedEvent{FromLabels: []string{"old"}, ToLabels: []string{"new"}},+ ApprovalCheckEvent{},+ }, result.Events)+}++func TestUpdateIssueMetadataDoesNotRequirePlanForDraftLabels(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "draft database change",+ Config: &storepb.PlanConfig{},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "draft database change",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Draft: true,+ Labels: []string{"old"},+ },+ })+ require.NoError(t, err)+ planTx, err := stores.GetDB().BeginTx(ctx, nil)+ require.NoError(t, err)+ defer planTx.Rollback()+ var planUID int64+ require.NoError(t, planTx.QueryRowContext(ctx, `+ SELECT id+ FROM plan+ WHERE project = $1 AND id = $2+ FOR UPDATE`, issue.ProjectID, plan.UID).Scan(&planUID))++ labels := []string{"new"}+ updateCtx, cancel := context.WithTimeout(ctx, 2*time.Second)+ defer cancel()+ result, err := NewWorkflow(stores).UpdateIssueMetadata(updateCtx, UpdateIssueMetadataInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Labels: &labels,+ })+ require.NoError(t, err)+ require.Equal(t, []string{"new"}, result.Issue.Payload.GetLabels())+ require.False(t, result.ApprovalReset)+ require.Equal(t, []Event{+ IssueLabelsUpdatedEvent{FromLabels: []string{"old"}, ToLabels: []string{"new"}},+ }, result.Events)+}++func TestLabelResetMakesPendingApprovalActionStale(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ _, err := stores.PatchWorkspaceIamPolicy(ctx, &store.PatchIamPolicyMessage{+ Workspace: "default",+ Member: common.FormatUserEmail("[email protected]"),+ Roles: []string{"roles/projectOwner"},+ })+ require.NoError(t, err)+ plan, issue := createPendingDatabaseChangeApproval(ctx, t, stores, []string{"roles/projectOwner"})+ config := proto.CloneOf(plan.Config)+ config.Specs = []*storepb.PlanConfig_Spec{{+ Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{+ ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{},+ },+ }}+ _, err = stores.UpdatePlan(ctx, &store.UpdatePlanMessage{UID: plan.UID, ProjectID: plan.ProjectID, Config: config})+ require.NoError(t, err)++ workflow := NewWorkflow(stores)+ proposalReady := make(chan struct{})+ releaseCommit := make(chan struct{})+ workflow.beforeCommit = func() {+ close(proposalReady)+ <-releaseCommit+ }+ type actionOutcome struct {+ result *IssueResult+ err error+ }+ actionDone := make(chan actionOutcome, 1)+ go func() {+ result, err := workflow.ReviewIssue(ctx, IssueInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Actor: &store.UserMessage{Email: "[email protected]"},+ Action: ActionApprove,+ })+ actionDone <- actionOutcome{result: result, err: err}+ }()+ <-proposalReady++ updatedLabels := []string{"security"}+ labels, err := NewWorkflow(stores).UpdateIssueMetadata(ctx, UpdateIssueMetadataInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ Labels: &updatedLabels,+ })+ require.NoError(t, err)+ require.True(t, labels.ApprovalReset)+ close(releaseCommit)++ action := <-actionDone+ require.Nil(t, action.result)+ err = action.err+ var workflowErr *Error+ require.True(t, errors.As(err, &workflowErr))+ require.Equal(t, ErrorConflict, workflowErr.Code)+ got, err := stores.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})+ require.NoError(t, err)+ require.Empty(t, got.Payload.GetApproval().GetApprovers())+}++func TestRolloutMakesPendingApprovalFindingStale(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ require.NoError(t, stores.UpdateProjects(ctx, &store.UpdateProjectMessage{+ Workspace: "default",+ ResourceID: "project-a",+ Setting: &storepb.Project{RequireIssueApproval: true},+ }))+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 2},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Approval: &storepb.IssuePayloadApproval{ApprovalInputVersion: 2},+ },+ })+ require.NoError(t, err)++ evaluator := &ApprovalEvaluator{workflow: NewWorkflow(stores)}+ evaluator.evaluateApproval = func(_ context.Context, issue *store.IssueMessage, _ *store.ProjectMessage, _ *storepb.WorkspaceApprovalSetting) error {+ issue.Payload.Approval = &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ }+ return nil+ }+ proposalReady := make(chan struct{})+ releaseCommit := make(chan struct{})+ evaluator.beforeCommit = func() {+ close(proposalReady)+ <-releaseCommit+ }+ applyDone := make(chan error, 1)+ go func() {+ _, err := evaluator.ApplyApprovalTemplate(ctx, ApplyApprovalTemplateInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ })+ applyDone <- err+ }()+ <-proposalReady++ approved := &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ }+ _, err = stores.UpdateIssue(ctx, issue.ProjectID, issue.UID, &store.UpdateIssueMessage{+ PayloadUpsert: &storepb.Issue{Approval: approved},+ })+ require.NoError(t, err)+ _, err = NewWorkflow(stores).CreateRollout(ctx, CreateRolloutInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ BuildTasks: func(context.Context, *store.PlanMessage, *store.ProjectMessage) ([]*store.TaskMessage, error) {+ return nil, nil+ },+ })+ require.NoError(t, err)+ close(releaseCommit)++ err = <-applyDone+ var workflowErr *Error+ require.True(t, errors.As(err, &workflowErr))+ require.Equal(t, ErrorConflict, workflowErr.Code)+}++func TestPlanMutationMakesIssueLessRolloutStale(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{+ ApprovalInputVersion: 2,+ Specs: []*storepb.PlanConfig_Spec{{Id: "old"}},+ },+ }, "[email protected]")+ require.NoError(t, err)++ buildStarted := make(chan struct{})+ releaseBuild := make(chan struct{})+ type rolloutOutcome struct {+ result *CreateRolloutResult+ err error+ }+ rolloutDone := make(chan rolloutOutcome, 1)+ go func() {+ result, err := NewWorkflow(stores).CreateRollout(ctx, CreateRolloutInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ BuildTasks: func(_ context.Context, _ *store.PlanMessage, _ *store.ProjectMessage) ([]*store.TaskMessage, error) {+ close(buildStarted)+ <-releaseBuild+ return nil, nil+ },+ })+ rolloutDone <- rolloutOutcome{result: result, err: err}+ }()+ <-buildStarted++ updated, err := NewWorkflow(stores).UpdatePlanSpecs(ctx, UpdatePlanSpecsInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Specs: []*storepb.PlanConfig_Spec{{Id: "new"}},+ })+ require.NoError(t, err)+ require.EqualValues(t, 3, updated.Plan.Config.GetApprovalInputVersion())+ close(releaseBuild)++ outcome := <-rolloutDone+ require.Nil(t, outcome.result)+ var workflowErr *Error+ require.ErrorAs(t, outcome.err, &workflowErr)+ require.Equal(t, ErrorConflict, workflowErr.Code)+ got, err := stores.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})+ require.NoError(t, err)+ require.False(t, got.Config.GetHasRollout())+}++func TestPlanMutationMakesPendingApprovalFindingStale(t *testing.T) {+ ctx := context.Background()+ stores := setupWorkflowStore(ctx, t)+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 2},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Approval: &storepb.IssuePayloadApproval{ApprovalInputVersion: 2},+ },+ })+ require.NoError(t, err)++ evaluator := &ApprovalEvaluator{workflow: NewWorkflow(stores)}+ evaluator.evaluateApproval = func(_ context.Context, issue *store.IssueMessage, _ *store.ProjectMessage, _ *storepb.WorkspaceApprovalSetting) error {+ issue.Payload.Approval = &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ }+ return nil+ }+ proposalReady := make(chan struct{})+ releaseCommit := make(chan struct{})+ evaluator.beforeCommit = func() {+ close(proposalReady)+ <-releaseCommit+ }+ type findingOutcome struct {+ result *ApplyApprovalTemplateResult+ err error+ }+ applyDone := make(chan findingOutcome, 1)+ go func() {+ result, err := evaluator.ApplyApprovalTemplate(ctx, ApplyApprovalTemplateInput{+ Workspace: "default",+ ProjectID: "project-a",+ IssueUID: issue.UID,+ })+ applyDone <- findingOutcome{result: result, err: err}+ }()+ <-proposalReady++ updated, err := NewWorkflow(stores).UpdatePlanSpecs(ctx, UpdatePlanSpecsInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ Specs: []*storepb.PlanConfig_Spec{{Id: "new"}},+ })+ require.NoError(t, err)+ require.True(t, updated.ApprovalReset)+ close(releaseCommit)++ finding := <-applyDone+ require.Nil(t, finding.result)+ err = finding.err+ var workflowErr *Error+ require.True(t, errors.As(err, &workflowErr))+ require.Equal(t, ErrorConflict, workflowErr.Code)+ got, err := stores.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})+ require.NoError(t, err)+ require.False(t, got.Payload.GetApproval().GetApprovalFindingDone())+ require.EqualValues(t, 3, got.Payload.GetApproval().GetApprovalInputVersion())+}++func setupWorkflowStore(ctx context.Context, t *testing.T) *store.Store {+ t.Helper()++ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(ctx) })++ db := container.GetDB()+ require.NoError(t, migrator.MigrateSchema(ctx, db))+ _, err := db.ExecContext(ctx, `+ INSERT INTO workspace (resource_id) VALUES ('default');+ INSERT INTO principal (name, email, password_hash) VALUES+ ('creator', '[email protected]', 'unused'),+ ('reviewer', '[email protected]', 'unused'),+ ('reviewer2', '[email protected]', 'unused');+ INSERT INTO project (resource_id, workspace, name) VALUES ('project-a', 'default', 'Project A');+ INSERT INTO instance (resource_id, workspace) VALUES ('instance-a', 'default');+ `)+ require.NoError(t, err)++ pgURL := fmt.Sprintf(+ "host=%s port=%s user=postgres password=root-password database=postgres",+ container.GetHost(), container.GetPort(),+ )+ stores, err := store.New(ctx, pgURL, false)+ require.NoError(t, err)+ t.Cleanup(func() { require.NoError(t, stores.Close()) })+ return stores+}++func createPendingDatabaseChangeApproval(ctx context.Context, t *testing.T, stores *store.Store, roles []string) (*store.PlanMessage, *store.IssueMessage) {+ t.Helper()+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{+ ProjectID: "project-a",+ Name: "change database",+ Config: &storepb.PlanConfig{ApprovalInputVersion: 2},+ }, "[email protected]")+ require.NoError(t, err)+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{+ ProjectID: "project-a",+ CreatorEmail: "[email protected]",+ Title: "change database",+ Type: storepb.Issue_DATABASE_CHANGE,+ PlanUID: &plan.UID,+ Payload: &storepb.Issue{+ Approval: &storepb.IssuePayloadApproval{+ ApprovalFindingDone: true,+ ApprovalInputVersion: 2,+ ApprovalTemplate: &storepb.ApprovalTemplate{+ Flow: &storepb.ApprovalFlow{Roles: roles},+ },+ },+ },+ })+ require.NoError(t, err)+ return plan, issue+}diff --git a/backend/server/server.go b/backend/server/server.goindex 81aa0f3561..2fe8b2477d 100644--- a/backend/server/server.go+++ b/backend/server/server.go@@ -25,6 +25,7 @@ import ("github.com/bytebase/bytebase/backend/component/config""github.com/bytebase/bytebase/backend/component/dbfactory""github.com/bytebase/bytebase/backend/component/iam"+ "github.com/bytebase/bytebase/backend/component/review""github.com/bytebase/bytebase/backend/component/sampleinstance""github.com/bytebase/bytebase/backend/component/sheet""github.com/bytebase/bytebase/backend/component/telemetry"@@ -34,7 +35,6 @@ import (v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/migrator""github.com/bytebase/bytebase/backend/resources/postgres"- "github.com/bytebase/bytebase/backend/runner/approval""github.com/bytebase/bytebase/backend/runner/cleaner""github.com/bytebase/bytebase/backend/runner/heartbeat""github.com/bytebase/bytebase/backend/runner/monitor"@@ -60,7 +60,7 @@ type Server struct {taskScheduler *taskrun.SchedulerplanCheckScheduler *plancheck.SchedulerschemaSyncer *schemasync.Syncer- approvalRunner *approval.Runner+ approvalRunner *review.RunnernotifyListener *notifylistener.ListenerdataCleaner *cleaner.DataCleanerheartbeatRunner *heartbeat.Runner@@ -214,7 +214,7 @@ func NewServer(ctx context.Context, profile *config.Profile) (*Server, error) {s.echoServer = echo.New()s.schemaSyncer = schemasync.NewSyncer(stores, s.dbFactory, s.licenseService)- s.approvalRunner = approval.NewRunner(stores, s.bus, s.webhookManager, s.licenseService)+ s.approvalRunner = review.NewRunner(stores, s.bus, s.webhookManager, s.licenseService)s.taskScheduler = taskrun.NewScheduler(stores, s.bus, s.webhookManager, s.licenseService, profile)s.taskScheduler.Register(storepb.Task_DATABASE_CREATE, taskrun.NewDatabaseCreateExecutor(stores, s.dbFactory, s.schemaSyncer))diff --git a/backend/store/advisory_lock.go b/backend/store/advisory_lock.goindex c21169c8ba..1b76f73937 100644--- a/backend/store/advisory_lock.go+++ b/backend/store/advisory_lock.go@@ -23,8 +23,8 @@ const (// AdvisoryLockKeyVCSProviderUser is used as the namespace for active VCS// provider user limit checks and upserts.AdvisoryLockKeyVCSProviderUser AdvisoryLockKey = 1004- // AdvisoryLockKeyPlanIssueRollout serializes linked issue creation and- // rollout creation for the same plan.+ // AdvisoryLockKeyPlanIssueRollout serializes Plan review changes, linked+ // Bytebase Issue creation, and Rollout creation for the same Plan.AdvisoryLockKeyPlanIssueRollout AdvisoryLockKey = 1005)diff --git a/backend/store/issue.go b/backend/store/issue.goindex 18616265ee..e4d2351942 100644--- a/backend/store/issue.go+++ b/backend/store/issue.go@@ -3,7 +3,6 @@ package storeimport ("context""database/sql"- "encoding/json""fmt""slices""strings"@@ -20,9 +19,6 @@ import (var getSegmenter func() *gse.Segmenter-// ErrIssueUpdateSkipped indicates that a guarded issue update did not match the current row state.-var ErrIssueUpdateSkipped = errors.New("issue update skipped")-func init() {var segmenterDic gse.Segmenterif err := segmenterDic.LoadDictEmbed("zh"); err != nil {@@ -81,23 +77,7 @@ type UpdateIssueMessage struct {Description *string// PayloadUpsert upserts the presented top-level keys.PayloadUpsert *storepb.Issue- // ConditionalPayloadUpsert upserts the presented top-level keys only if- // ConditionalPlanApprovalInputVersion matches. The main update still applies- // if it does not.- ConditionalPayloadUpsert *storepb.Issue- RemoveLabels bool-- RequirePlanApprovalInputVersion *int64- RequireIssueApprovalInputVersion *int64- RequireApprovalFindingDone *bool- RequireLabels *[]string- RequireNoRollout bool- // SkipIfCurrentApprovalFindingDone skips when approval finding is already done- // for the same approval input version.- SkipIfCurrentApprovalFindingDone *int64-- ConditionalPlanApprovalInputVersion *int64- ConditionalRequireNoRollout bool+ RemoveLabels bool}// FindIssueMessage is the message to find issues.@@ -263,9 +243,27 @@ func (s *Store) UpdateIssue(ctx context.Context, projectID string, uid int64, paif err != nil {return nil, err}+ if _, err := updateIssue(ctx, s.GetDB(), projectID, uid, oldIssue, patch); err != nil {+ return nil, err+ }++ return s.GetIssue(ctx, &FindIssueMessage{ProjectIDs: []string{projectID}, UID: &uid})+}++// UpdateIssueTx updates an already locked Issue inside a caller-owned transaction.+func UpdateIssueTx(ctx context.Context, tx *sql.Tx, issue *IssueMessage, patch *UpdateIssueMessage) (time.Time, error) {+ return updateIssue(ctx, tx, issue.ProjectID, issue.UID, issue, patch)+}++type issueUpdateExecutor interface {+ ExecContext(context.Context, string, ...any) (sql.Result, error)+}++func updateIssue(ctx context.Context, executor issueUpdateExecutor, projectID string, uid int64, oldIssue *IssueMessage, patch *UpdateIssueMessage) (time.Time, error) {+ updatedAt := time.Now()set := qb.Q()- set.Comma("updated_at = ?", time.Now())+ set.Comma("updated_at = ?", updatedAt)if v := patch.Title; v != nil {set.Comma("name = ?", *v)@@ -281,25 +279,13 @@ func (s *Store) UpdateIssue(ctx context.Context, projectID string, uid int64, pav.Labels = CanonicalizeIssueLabels(v.Labels)p, err := protojson.Marshal(v)if err != nil {- return nil, errors.Wrapf(err, "failed to marshal patch.PayloadUpsert")+ return time.Time{}, errors.Wrapf(err, "failed to marshal patch.PayloadUpsert")}payloadSet.Space("|| ?::jsonb", string(p))}if patch.RemoveLabels {payloadSet.Space("|| jsonb_build_object('labels', ?::JSONB)", nil)}- if v := patch.ConditionalPayloadUpsert; v != nil {- if patch.ConditionalPlanApprovalInputVersion == nil {- return nil, errors.New("ConditionalPayloadUpsert requires ConditionalPlanApprovalInputVersion")- }- v.Labels = CanonicalizeIssueLabels(v.Labels)- p, err := protojson.Marshal(v)- if err != nil {- return nil, errors.Wrapf(err, "failed to marshal patch.ConditionalPayloadUpsert")- }- condition := issuePlanApprovalInputVersionCondition(*patch.ConditionalPlanApprovalInputVersion, patch.ConditionalRequireNoRollout)- payloadSet.Space("|| CASE WHEN ? THEN ?::jsonb ELSE '{}'::jsonb END", condition, string(p))- }if payloadSet.Len() > 1 {set.Comma("payload = ?", payloadSet)}@@ -318,215 +304,17 @@ func (s *Store) UpdateIssue(ctx context.Context, projectID string, uid int64, paset.Comma("ts_vector = ?", tsVector)}- where, hasGuard, err := buildUpdateIssueGuard(patch, projectID, uid)- if err != nil {- return nil, err- }- q := qb.Q().Space("UPDATE issue SET ? WHERE ?", set, where)-- query, args, err := q.ToSQL()- if err != nil {- return nil, errors.Wrapf(err, "failed to build sql")- }-- result, err := s.GetDB().ExecContext(ctx, query, args...)- if err != nil {- return nil, err- }- if hasGuard {- rowsAffected, err := result.RowsAffected()- if err != nil {- return nil, errors.Wrapf(err, "failed to inspect issue update")- }- if rowsAffected == 0 {- return nil, ErrIssueUpdateSkipped- }- }-- return s.GetIssue(ctx, &FindIssueMessage{ProjectIDs: []string{projectID}, UID: &uid})-}--// UpdateIssueLabelsAndMaybeResetApproval updates issue labels and, while the linked plan-// has no rollout, resets approval in the same transaction. This remains separate from-// generic UpdateIssue because labels and approval reset are one domain invariant here:-// composing a label write with a conditional approval reset can persist labels while-// silently skipping the reset during plan-version or rollout races.-func (s *Store) UpdateIssueLabelsAndMaybeResetApproval(ctx context.Context, projectID string, uid int64, labels []string) (*IssueMessage, bool, error) {- labels = CanonicalizeIssueLabels(labels)-- tx, err := s.GetDB().BeginTx(ctx, nil)- if err != nil {- return nil, false, errors.Wrapf(err, "failed to begin tx")- }- defer tx.Rollback()-- var planUID sql.NullInt64- currentPayload := &storepb.Issue{}- var payload []byte- if err := tx.QueryRowContext(ctx, `- SELECT plan_id, payload- FROM issue- WHERE project = $1- AND id = $2- FOR UPDATE`,- projectID, uid).Scan(&planUID, &payload); err != nil {- if errors.Is(err, sql.ErrNoRows) {- return nil, false, nil- }- return nil, false, errors.Wrapf(err, "failed to lock issue")- }- if err := common.ProtojsonUnmarshaler.Unmarshal(payload, currentPayload); err != nil {- return nil, false, errors.Wrap(err, "failed to unmarshal issue payload")- }- if slices.Equal(CanonicalizeIssueLabels(currentPayload.GetLabels()), labels) {- if err := tx.Commit(); err != nil {- return nil, false, errors.Wrapf(err, "failed to commit tx")- }- issue, err := s.GetIssue(ctx, &FindIssueMessage{ProjectIDs: []string{projectID}, UID: &uid})- if err != nil {- return nil, false, err- }- return issue, false, nil- }-- approvalResetApplied := false- var approvalInputVersion int64- if planUID.Valid {- planConfig := &storepb.PlanConfig{}- var config []byte- if err := tx.QueryRowContext(ctx, `- SELECT config- FROM plan- WHERE project = $1- AND id = $2- FOR UPDATE`,- projectID, planUID.Int64).Scan(&config); err != nil {- if errors.Is(err, sql.ErrNoRows) {- return nil, false, errors.Errorf("plan %d not found", planUID.Int64)- }- return nil, false, errors.Wrapf(err, "failed to lock plan")- }- if err := common.ProtojsonUnmarshaler.Unmarshal(config, planConfig); err != nil {- return nil, false, errors.Wrap(err, "failed to unmarshal plan config")- }- if !planConfig.GetHasRollout() {- approvalResetApplied = true- approvalInputVersion = planConfig.GetApprovalInputVersion()- }- }+ q := qb.Q().Space("UPDATE issue SET ? WHERE project = ? AND id = ?", set, projectID, uid)- payloadSet := qb.Q().Space("payload")- if len(labels) == 0 {- payloadSet.Space("|| jsonb_build_object('labels', ?::JSONB)", nil)- } else {- p, err := protojson.Marshal(&storepb.Issue{Labels: labels})- if err != nil {- return nil, false, errors.Wrapf(err, "failed to marshal issue labels")- }- payloadSet.Space("|| ?::jsonb", string(p))- }- if approvalResetApplied {- p, err := protojson.Marshal(&storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: approvalInputVersion,- },- })- if err != nil {- return nil, false, errors.Wrapf(err, "failed to marshal issue approval reset")- }- payloadSet.Space("|| ?::jsonb", string(p))- }-- q := qb.Q().Space(`- UPDATE issue- SET- updated_at = ?,- payload = ?- WHERE project = ?- AND id = ?`,- time.Now(), payloadSet, projectID, uid)query, args, err := q.ToSQL()if err != nil {- return nil, false, errors.Wrapf(err, "failed to build sql")- }- if _, err := tx.ExecContext(ctx, query, args...); err != nil {- return nil, false, err- }-- if err := tx.Commit(); err != nil {- return nil, false, errors.Wrapf(err, "failed to commit tx")- }-- issue, err := s.GetIssue(ctx, &FindIssueMessage{ProjectIDs: []string{projectID}, UID: &uid})- if err != nil {- return nil, false, err+ return time.Time{}, errors.Wrapf(err, "failed to build sql")}- return issue, approvalResetApplied, nil-}-func marshalCanonicalIssueLabels(labels []string) ([]byte, error) {- canonicalLabels := CanonicalizeIssueLabels(labels)- if canonicalLabels == nil {- canonicalLabels = []string{}- }- labelBytes, err := json.Marshal(canonicalLabels)- if err != nil {- return nil, errors.Wrapf(err, "failed to marshal issue labels")+ if _, err := executor.ExecContext(ctx, query, args...); err != nil {+ return time.Time{}, err}- return labelBytes, nil-}--func buildUpdateIssueGuard(patch *UpdateIssueMessage, projectID string, uid int64) (*qb.Query, bool, error) {- where := qb.Q().Space("project = ? AND id = ?", projectID, uid)- hasGuard := false- if version := patch.RequirePlanApprovalInputVersion; version != nil {- where.Space("AND ?", issuePlanApprovalInputVersionCondition(*version, patch.RequireNoRollout))- hasGuard = true- } else if patch.RequireNoRollout {- return nil, false, errors.New("RequireNoRollout requires RequirePlanApprovalInputVersion")- }- if version := patch.RequireIssueApprovalInputVersion; version != nil {- where.Space("AND COALESCE((payload->'approval'->>'approvalInputVersion')::bigint, 0) = ?", *version)- hasGuard = true- }- if done := patch.RequireApprovalFindingDone; done != nil {- where.Space("AND COALESCE((payload->'approval'->>'approvalFindingDone')::boolean, false) = ?", *done)- hasGuard = true- }- if labels := patch.RequireLabels; labels != nil {- labelBytes, err := marshalCanonicalIssueLabels(*labels)- if err != nil {- return nil, false, err- }- where.Space("AND COALESCE(NULLIF(payload->'labels', 'null'::jsonb), '[]'::jsonb) = ?::jsonb", string(labelBytes))- hasGuard = true- }- if version := patch.SkipIfCurrentApprovalFindingDone; version != nil {- where.Space(`- AND NOT (- COALESCE((payload->'approval'->>'approvalFindingDone')::boolean, false)- AND COALESCE((payload->'approval'->>'approvalInputVersion')::bigint, 0) = ?- )`, *version)- hasGuard = true- }- return where, hasGuard, nil-}--func issuePlanApprovalInputVersionCondition(approvalInputVersion int64, requireNoRollout bool) *qb.Query {- planWhere := qb.Q().Space(`- plan.project = issue.project- AND plan.id = issue.plan_id- AND COALESCE((plan.config->>'approvalInputVersion')::bigint, 0) = ?`, approvalInputVersion)- if requireNoRollout {- planWhere.Space("AND COALESCE((plan.config->>'hasRollout')::boolean, false) = false")- }- return qb.Q().Space(`- EXISTS (- SELECT 1- FROM plan- WHERE ?- )`, planWhere)+ return updatedAt, nil}// ListIssues returns the list of issues by find query.diff --git a/backend/store/plan.go b/backend/store/plan.goindex c90e9f68cc..aa5c5c4e0b 100644--- a/backend/store/plan.go+++ b/backend/store/plan.go@@ -2,7 +2,6 @@ package storeimport ("context"- "database/sql""strings""time"@@ -62,17 +61,8 @@ type UpdatePlanMessage struct {// Config replaces the entire plan config.// Callers should clone the existing config and modify only the fields they want to change.// Example: config := proto.CloneOf(plan.Config); config.HasRollout = true; patch.Config = config- Config *storepb.PlanConfig- // BumpApprovalInputVersion increments config.approvalInputVersion from the- // current stored row while applying Config as a full replacement. Use this- // only for approval-relevant full config replacements such as spec updates.- BumpApprovalInputVersion bool- // RequireNoRollout rejects full config replacements once rollout marking has- // won the race. This is separate from BumpApprovalInputVersion because the- // user-visible invariant is about spec immutability after rollout, including- // spec edits that do not otherwise affect approval input.- RequireNoRollout bool- Deleted *bool+ Config *storepb.PlanConfig+ Deleted *bool}// CreatePlan creates a new plan.@@ -242,17 +232,10 @@ func (s *Store) UpdatePlan(ctx context.Context, patch *UpdatePlanMessage) (*Planif err != nil {return nil, errors.Wrapf(err, "failed to marshal plan config")}- if patch.BumpApprovalInputVersion {- set.Comma("config = jsonb_set(?::jsonb, '{approvalInputVersion}', to_jsonb(COALESCE((config->>'approvalInputVersion')::bigint, 0) + 1), true)", config)- } else {- set.Comma("config = ?", config)- }+ set.Comma("config = ?", config)}where := qb.Q().Space("id = ? AND project = ?", patch.UID, patch.ProjectID)- if patch.RequireNoRollout {- where.Space("AND COALESCE((config->>'hasRollout')::boolean, false) = false")- }q := qb.Q().Space(`UPDATE plan SET ? WHERE ?RETURNING id, creator, created_at, updated_at, project, name, description, config, deleted`,@@ -278,9 +261,6 @@ func (s *Store) UpdatePlan(ctx context.Context, patch *UpdatePlanMessage) (*Plan&config,&plan.Deleted,); err != nil {- if patch.RequireNoRollout && errors.Is(err, sql.ErrNoRows) {- return nil, ErrPlanHasRollout- }return nil, errors.Wrapf(err, "failed to update plan")}if err := common.ProtojsonUnmarshaler.Unmarshal(config, plan.Config); err != nil {diff --git a/backend/store/plan_approval_input_version_test.go b/backend/store/plan_approval_input_version_test.godeleted file mode 100644index 8d7f12d88c..0000000000--- a/backend/store/plan_approval_input_version_test.go+++ /dev/null@@ -1,1334 +0,0 @@-package store_test--import (- "context"- "fmt"- "testing"-- "github.com/stretchr/testify/require"- "google.golang.org/protobuf/proto"-- "github.com/bytebase/bytebase/backend/common/testcontainer"- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/migrator"- "github.com/bytebase/bytebase/backend/store"-- _ "github.com/bytebase/bytebase/backend/plugin/db/pg"-)--func TestUpdatePlanBumpsApprovalInputVersionOnlyWhenRequested(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- created, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-a"}},- },- }, "[email protected]")- require.NoError(t, err)- require.EqualValues(t, 0, created.Config.GetApprovalInputVersion())- requirePlanSpecID(t, created.Config, "spec-a")-- config := &storepb.PlanConfig{- ApprovalInputVersion: 99,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-b"}},- }- updated, err := s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: created.UID,- ProjectID: created.ProjectID,- Config: config,- BumpApprovalInputVersion: true,- })- require.NoError(t, err)- require.EqualValues(t, 1, updated.Config.GetApprovalInputVersion())- requirePlanSpecID(t, updated.Config, "spec-b")-- description := "description-only"- updated, err = s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: created.UID,- ProjectID: created.ProjectID,- Description: &description,- })- require.NoError(t, err)- require.EqualValues(t, 1, updated.Config.GetApprovalInputVersion())- requirePlanSpecID(t, updated.Config, "spec-b")-- config = &storepb.PlanConfig{- ApprovalInputVersion: 99,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-c"}},- }- updated, err = s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: created.UID,- ProjectID: created.ProjectID,- Config: config,- BumpApprovalInputVersion: true,- })- require.NoError(t, err)- require.EqualValues(t, 2, updated.Config.GetApprovalInputVersion())- requirePlanSpecID(t, updated.Config, "spec-c")-- config = &storepb.PlanConfig{- ApprovalInputVersion: 7,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-d"}},- }- updated, err = s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: created.UID,- ProjectID: created.ProjectID,- Config: config,- })- require.NoError(t, err)- require.EqualValues(t, 7, updated.Config.GetApprovalInputVersion())- requirePlanSpecID(t, updated.Config, "spec-d")-- config = &storepb.PlanConfig{- ApprovalInputVersion: 99,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-e"}},- }- updated, err = s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: created.UID,- ProjectID: created.ProjectID,- Config: config,- BumpApprovalInputVersion: true,- })- require.NoError(t, err)- require.EqualValues(t, 8, updated.Config.GetApprovalInputVersion())- requirePlanSpecID(t, updated.Config, "spec-e")-}--func TestCreateRolloutTasksRequiresMatchingApprovalInputVersion(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{- ApprovalInputVersion: 2,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-a"}},- },- }, "[email protected]")- require.NoError(t, err)-- staleVersion := int64(1)- updated, createdTasks, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: staleVersion}, nil)- require.NoError(t, err)- require.False(t, updated)- require.Empty(t, createdTasks)-- got, err := s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.False(t, got.Config.GetHasRollout())- require.EqualValues(t, 2, got.Config.GetApprovalInputVersion())- requirePlanSpecID(t, got.Config, "spec-a")-- currentVersion := int64(2)- updated, createdTasks, err = s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: currentVersion}, nil)- require.NoError(t, err)- require.True(t, updated)- require.Empty(t, createdTasks)-- got, err = s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.True(t, got.Config.GetHasRollout())- require.EqualValues(t, 2, got.Config.GetApprovalInputVersion())- requirePlanSpecID(t, got.Config, "spec-a")-}--func TestCreateRolloutTasksRequiresCurrentIssueApproval(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{- ApprovalInputVersion: 2,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-a"}},- },- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- ApprovalTemplate: &storepb.ApprovalTemplate{- Flow: &storepb.ApprovalFlow{Roles: []string{"roles/sql-reviewer"}},- },- Approvers: []*storepb.IssuePayloadApproval_Approver{- {- Status: storepb.IssuePayloadApproval_Approver_APPROVED,- Principal: "users/[email protected]",- },- },- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- approvedIssueApproval := &storepb.IssuePayloadApproval{}- proto.Merge(approvedIssueApproval, issue.Payload.GetApproval())- updatedIssue, err := s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{Labels: []string{"security"}},- ConditionalPayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: approvalInputVersion,- },- },- ConditionalPlanApprovalInputVersion: &approvalInputVersion,- ConditionalRequireNoRollout: true,- })- require.NoError(t, err)- require.False(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, updatedIssue.Payload.GetApproval().GetApprovalInputVersion())- require.Equal(t, []string{"security"}, updatedIssue.Payload.Labels)-- updatedRollout, createdTasks, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{- IssueUID: issue.UID,- ApprovalInputVersion: approvalInputVersion,- Approval: approvedIssueApproval,- }, nil)- require.NoError(t, err)- require.False(t, updatedRollout)- require.Empty(t, createdTasks)-- got, err := s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.False(t, got.Config.GetHasRollout())- require.EqualValues(t, 2, got.Config.GetApprovalInputVersion())-- labels := []string{"security"}- recomputedIssue, err := s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- ApprovalTemplate: &storepb.ApprovalTemplate{- Flow: &storepb.ApprovalFlow{Roles: []string{"roles/sql-reviewer"}},- },- Approvers: []*storepb.IssuePayloadApproval_Approver{- {- Status: storepb.IssuePayloadApproval_Approver_APPROVED,- Principal: "users/[email protected]",- },- },- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- })- require.NoError(t, err)- require.False(t, approvedIssueApproval.Equal(recomputedIssue.Payload.GetApproval()))-- updatedRollout, createdTasks, err = s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{- IssueUID: issue.UID,- ApprovalInputVersion: approvalInputVersion,- Approval: approvedIssueApproval,- }, nil)- require.NoError(t, err)- require.False(t, updatedRollout)- require.Empty(t, createdTasks)-- got, err = s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.False(t, got.Config.GetHasRollout())- require.EqualValues(t, 2, got.Config.GetApprovalInputVersion())-- currentIssueApproval := &storepb.IssuePayloadApproval{}- proto.Merge(currentIssueApproval, recomputedIssue.Payload.GetApproval())- updatedRollout, createdTasks, err = s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{- IssueUID: issue.UID,- ApprovalInputVersion: approvalInputVersion,- Approval: currentIssueApproval,- }, nil)- require.NoError(t, err)- require.True(t, updatedRollout)- require.Empty(t, createdTasks)-- got, err = s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.True(t, got.Config.GetHasRollout())- require.EqualValues(t, 2, got.Config.GetApprovalInputVersion())-}--func TestCreateRolloutTasksAddsMissingTasksAfterRolloutExists(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 1},- }, "[email protected]")- require.NoError(t, err)-- updated, createdTasks, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, nil, []*store.TaskMessage{- newTestRolloutTask("instance-a", "database-a", "sheet-a"),- })- require.NoError(t, err)- require.True(t, updated)- require.Len(t, createdTasks, 1)-- got, err := s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.True(t, got.Config.GetHasRollout())-- updated, createdTasks, err = s.CreateRolloutTasks(ctx, "project-a", plan.UID, nil, []*store.TaskMessage{- newTestRolloutTask("instance-a", "database-a", "sheet-a"),- newTestRolloutTask("instance-a", "database-b", "sheet-b"),- })- require.NoError(t, err)- require.True(t, updated)- require.Len(t, createdTasks, 1)- require.Equal(t, "instance-a", createdTasks[0].InstanceID)- require.Equal(t, "database-b", createdTasks[0].GetDatabaseName())- require.Equal(t, "sheet-b", createdTasks[0].Payload.GetSheetSha256())-}--func TestUpdatePlanRequireNoRolloutDoesNotOverwriteRollout(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{- ApprovalInputVersion: 1,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-a"}},- },- }, "[email protected]")- require.NoError(t, err)-- staleConfig := proto.CloneOf(plan.Config)- staleConfig.Specs = []*storepb.PlanConfig_Spec{{Id: "spec-b"}}-- approvalInputVersion := int64(1)- marked, _, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)- require.NoError(t, err)- require.True(t, marked)-- _, err = s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: plan.UID,- ProjectID: "project-a",- Config: staleConfig,- BumpApprovalInputVersion: true,- RequireNoRollout: true,- })- require.Error(t, err)-- got, err := s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.True(t, got.Config.GetHasRollout())- require.EqualValues(t, 1, got.Config.GetApprovalInputVersion())- requirePlanSpecID(t, got.Config, "spec-a")-}--func TestUpdatePlanRequireNoRolloutRejectsConfigUpdateAfterRollout(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{- ApprovalInputVersion: 1,- Specs: []*storepb.PlanConfig_Spec{{Id: "spec-a"}},- },- }, "[email protected]")- require.NoError(t, err)-- staleConfig := proto.CloneOf(plan.Config)- staleConfig.Specs = []*storepb.PlanConfig_Spec{{Id: "spec-b"}}-- approvalInputVersion := int64(1)- marked, _, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)- require.NoError(t, err)- require.True(t, marked)-- _, err = s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: plan.UID,- ProjectID: "project-a",- Config: staleConfig,- RequireNoRollout: true,- })- require.Error(t, err)- require.ErrorIs(t, err, store.ErrPlanHasRollout)-- got, err := s.GetPlan(ctx, &store.FindPlanMessage{ProjectID: "project-a", UID: &plan.UID})- require.NoError(t, err)- require.True(t, got.Config.GetHasRollout())- require.EqualValues(t, 1, got.Config.GetApprovalInputVersion())- requirePlanSpecID(t, got.Config, "spec-a")-}--func TestUpdateIssueWithPlanApprovalInputVersionGuardUpdatesMatchingVersion(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{RiskLevel: storepb.RiskLevel_LOW},- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- })- require.NoError(t, err)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.NotNil(t, got)- require.Equal(t, storepb.RiskLevel_HIGH, got.Payload.GetRiskLevel())- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssuePayloadUpsertCanRemoveLabels(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- RiskLevel: storepb.RiskLevel_LOW,- },- })- require.NoError(t, err)-- updatedIssue, err := s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{RiskLevel: storepb.RiskLevel_HIGH},- RemoveLabels: true,- })- require.NoError(t, err)- require.Empty(t, updatedIssue.Payload.GetLabels())- require.Equal(t, storepb.RiskLevel_HIGH, updatedIssue.Payload.GetRiskLevel())-}--func TestUpdateIssueConditionalPayloadRequiresPlanGuard(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{},- })- require.NoError(t, err)-- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- ConditionalPayloadUpsert: &storepb.Issue{RiskLevel: storepb.RiskLevel_HIGH},- })- require.ErrorContains(t, err, "ConditionalPayloadUpsert requires ConditionalPlanApprovalInputVersion")-}--func TestUpdateIssueWithPlanApprovalInputVersionGuardSkipsStaleVersion(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{RiskLevel: storepb.RiskLevel_LOW},- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(1)- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 1,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- })- require.ErrorIs(t, err, store.ErrIssueUpdateSkipped)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.NotNil(t, got)- require.Equal(t, storepb.RiskLevel_LOW, got.Payload.GetRiskLevel())- require.Nil(t, got.Payload.GetApproval())-}--func TestUpdateIssueWithPlanApprovalInputVersionGuardSkipsIssueWithoutPlan(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{RiskLevel: storepb.RiskLevel_LOW},- })- require.NoError(t, err)-- approvalInputVersion := int64(0)- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- })- require.ErrorIs(t, err, store.ErrIssueUpdateSkipped)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.NotNil(t, got)- require.Equal(t, storepb.RiskLevel_LOW, got.Payload.GetRiskLevel())- require.Nil(t, got.Payload.GetApproval())-}--func TestUpdateIssueWithPlanApprovalInputVersionAndLabelsGuardsUpdatesMatchingLabels(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod", "security"},- RiskLevel: storepb.RiskLevel_LOW,- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- labels := []string{"security", "prod", "prod"}- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- })- require.NoError(t, err)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.Equal(t, storepb.RiskLevel_HIGH, got.Payload.GetRiskLevel())- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithPlanApprovalInputVersionAndLabelsGuardsUpdatesEmptyLabels(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{RiskLevel: storepb.RiskLevel_LOW},- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- var labels []string- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- })- require.NoError(t, err)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.Equal(t, storepb.RiskLevel_HIGH, got.Payload.GetRiskLevel())- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithPlanApprovalInputVersionAndLabelsGuardsUpdatesJSONNullLabels(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- RiskLevel: storepb.RiskLevel_LOW,- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedIssue, err := s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{RemoveLabels: true})- require.NoError(t, err)- require.Empty(t, updatedIssue.Payload.GetLabels())-- approvalInputVersion := int64(2)- var labels []string- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- })- require.NoError(t, err)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.Empty(t, got.Payload.GetLabels())- require.Equal(t, storepb.RiskLevel_HIGH, got.Payload.GetRiskLevel())- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithPlanApprovalInputVersionAndLabelsGuardsSkipsStaleLabels(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- RiskLevel: storepb.RiskLevel_LOW,- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedIssue, err := s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{Labels: []string{"stage"}},- })- require.NoError(t, err)- require.Equal(t, []string{"stage"}, updatedIssue.Payload.GetLabels())-- approvalInputVersion := int64(2)- labels := []string{"prod"}- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- })- require.ErrorIs(t, err, store.ErrIssueUpdateSkipped)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.Equal(t, storepb.RiskLevel_LOW, got.Payload.GetRiskLevel())- require.Nil(t, got.Payload.GetApproval())-}--func TestUpdateIssueWithPlanApprovalInputVersionLabelsAndNoRolloutGuardsUpdatesBeforeRollout(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod", "security"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- labels := []string{"security", "prod", "prod"}- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- RequireNoRollout: true,- })- require.NoError(t, err)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.False(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithPlanApprovalInputVersionLabelsAndNoRolloutGuardsUpdatesJSONNullLabels(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedIssue, err := s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{RemoveLabels: true})- require.NoError(t, err)- require.Empty(t, updatedIssue.Payload.GetLabels())-- approvalInputVersion := int64(2)- var labels []string- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- RequireNoRollout: true,- })- require.NoError(t, err)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.Empty(t, got.Payload.GetLabels())- require.False(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithPlanApprovalInputVersionLabelsAndNoRolloutGuardsSkipsAfterRollout(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod", "security"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- marked, _, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)- require.NoError(t, err)- require.True(t, marked)-- labels := []string{"security", "prod", "prod"}- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- RequireNoRollout: true,- })- require.ErrorIs(t, err, store.ErrIssueUpdateSkipped)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueConditionalPayloadSkipsAfterRolloutButMainUpdateApplies(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- marked, _, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)- require.NoError(t, err)- require.True(t, marked)-- updatedIssue, err := s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{Labels: []string{"stage"}},- ConditionalPayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: approvalInputVersion,- },- },- ConditionalPlanApprovalInputVersion: &approvalInputVersion,- ConditionalRequireNoRollout: true,- })- require.NoError(t, err)- require.Equal(t, []string{"stage"}, updatedIssue.Payload.GetLabels())- require.True(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, updatedIssue.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueLabelsAndMaybeResetApprovalResetsBeforeRollout(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedIssue, approvalResetApplied, err := s.UpdateIssueLabelsAndMaybeResetApproval(ctx, "project-a", issue.UID, []string{"stage"})- require.NoError(t, err)- require.True(t, approvalResetApplied)- require.Equal(t, []string{"stage"}, updatedIssue.Payload.GetLabels())- require.False(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, updatedIssue.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueLabelsAndMaybeResetApprovalDoesNotResetAfterRollout(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- marked, _, err := s.CreateRolloutTasks(ctx, "project-a", plan.UID, &store.IssueApprovalGuard{ApprovalInputVersion: approvalInputVersion}, nil)- require.NoError(t, err)- require.True(t, marked)-- updatedIssue, approvalResetApplied, err := s.UpdateIssueLabelsAndMaybeResetApproval(ctx, "project-a", issue.UID, []string{"stage"})- require.NoError(t, err)- require.False(t, approvalResetApplied)- require.Equal(t, []string{"stage"}, updatedIssue.Payload.GetLabels())- require.True(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, updatedIssue.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueLabelsAndMaybeResetApprovalUsesCurrentPlanVersion(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedPlan, err := s.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: plan.UID,- ProjectID: plan.ProjectID,- Config: plan.Config,- BumpApprovalInputVersion: true,- })- require.NoError(t, err)- require.EqualValues(t, 3, updatedPlan.Config.GetApprovalInputVersion())-- updatedIssue, approvalResetApplied, err := s.UpdateIssueLabelsAndMaybeResetApproval(ctx, "project-a", issue.UID, []string{"stage"})- require.NoError(t, err)- require.True(t, approvalResetApplied)- require.Equal(t, []string{"stage"}, updatedIssue.Payload.GetLabels())- require.False(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 3, updatedIssue.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueLabelsAndMaybeResetApprovalNoopsWhenLockedLabelsMatch(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- Labels: []string{"prod"},- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- updatedIssue, approvalResetApplied, err := s.UpdateIssueLabelsAndMaybeResetApproval(ctx, "project-a", issue.UID, []string{"stage"})- require.NoError(t, err)- require.True(t, approvalResetApplied)- require.Equal(t, []string{"stage"}, updatedIssue.Payload.GetLabels())- require.False(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())-- approvalInputVersion := int64(2)- labels := []string{"stage"}- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: approvalInputVersion,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireLabels: &labels,- })- require.NoError(t, err)-- updatedIssue, approvalResetApplied, err = s.UpdateIssueLabelsAndMaybeResetApproval(ctx, "project-a", issue.UID, []string{"stage"})- require.NoError(t, err)- require.False(t, approvalResetApplied)- require.Equal(t, []string{"stage"}, updatedIssue.Payload.GetLabels())- require.True(t, updatedIssue.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, updatedIssue.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithCurrentDoneApprovalGuardSkipsCurrentDoneApproval(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: false,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- SkipIfCurrentApprovalFindingDone: &approvalInputVersion,- })- require.ErrorIs(t, err, store.ErrIssueUpdateSkipped)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.NotNil(t, got)- require.Equal(t, storepb.RiskLevel_HIGH, got.Payload.GetRiskLevel())- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithCurrentApprovalInputVersionGuardsUpdatesMatchingVersion(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- RiskLevel: storepb.RiskLevel_LOW,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 2,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireIssueApprovalInputVersion: &approvalInputVersion,- })- require.NoError(t, err)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.NotNil(t, got)- require.Equal(t, storepb.RiskLevel_HIGH, got.Payload.GetRiskLevel())- require.True(t, got.Payload.GetApproval().GetApprovalFindingDone())- require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())-}--func TestUpdateIssueWithCurrentApprovalInputVersionGuardsSkipsStaleIssueApprovalVersion(t *testing.T) {- ctx := context.Background()- s := setupPlanApprovalInputVersionStore(ctx, t)-- plan, err := s.CreatePlan(ctx, &store.PlanMessage{- ProjectID: "project-a",- Name: "plan-a",- Description: "",- Config: &storepb.PlanConfig{ApprovalInputVersion: 2},- }, "[email protected]")- require.NoError(t, err)-- issue, err := s.CreateIssue(ctx, &store.IssueMessage{- ProjectID: "project-a",- CreatorEmail: "[email protected]",- Title: "issue-a",- Type: storepb.Issue_DATABASE_CHANGE,- Description: "",- Payload: &storepb.Issue{- RiskLevel: storepb.RiskLevel_LOW,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 1,- },- },- PlanUID: &plan.UID,- })- require.NoError(t, err)-- approvalInputVersion := int64(2)- _, err = s.UpdateIssue(ctx, "project-a", issue.UID, &store.UpdateIssueMessage{- PayloadUpsert: &storepb.Issue{- RiskLevel: storepb.RiskLevel_HIGH,- Approval: &storepb.IssuePayloadApproval{- ApprovalFindingDone: true,- ApprovalInputVersion: 1,- },- },- RequirePlanApprovalInputVersion: &approvalInputVersion,- RequireIssueApprovalInputVersion: &approvalInputVersion,- })- require.ErrorIs(t, err, store.ErrIssueUpdateSkipped)-- got, err := s.GetIssue(ctx, &store.FindIssueMessage{ProjectIDs: []string{"project-a"}, UID: &issue.UID})- require.NoError(t, err)- require.NotNil(t, got)- require.Equal(t, storepb.RiskLevel_LOW, got.Payload.GetRiskLevel())- require.EqualValues(t, 1, got.Payload.GetApproval().GetApprovalInputVersion())-}--func requirePlanSpecID(t *testing.T, config *storepb.PlanConfig, id string) {- t.Helper()- require.Len(t, config.GetSpecs(), 1)- require.Equal(t, id, config.GetSpecs()[0].GetId())-}--func newTestRolloutTask(instanceID string, databaseName string, sheetSha256 string) *store.TaskMessage {- return &store.TaskMessage{- InstanceID: instanceID,- DatabaseName: &databaseName,- Type: storepb.Task_DATABASE_MIGRATE,- Payload: &storepb.Task{- Source: &storepb.Task_SheetSha256{- SheetSha256: sheetSha256,- },- },- }-}--func setupPlanApprovalInputVersionStore(ctx context.Context, t *testing.T) *store.Store {- t.Helper()-- container := testcontainer.GetTestPgContainer(ctx, t)- t.Cleanup(func() { container.Close(ctx) })-- db := container.GetDB()- require.NoError(t, migrator.MigrateSchema(ctx, db))-- _, err := db.ExecContext(ctx, `- INSERT INTO workspace (resource_id) VALUES ('default');- INSERT INTO principal (name, email, password_hash) VALUES ('creator', '[email protected]', 'unused');- INSERT INTO project (resource_id, workspace, name) VALUES ('project-a', 'default', 'Project A');- INSERT INTO instance (resource_id, workspace) VALUES ('instance-a', 'default');- `)- require.NoError(t, err)-- pgURL := fmt.Sprintf(- "host=%s port=%s user=postgres password=root-password database=postgres",- container.GetHost(), container.GetPort(),- )- s, err := store.New(ctx, pgURL, false)- require.NoError(t, err)- t.Cleanup(func() { require.NoError(t, s.Close()) })- return s-}diff --git a/backend/store/plan_check_run.go b/backend/store/plan_check_run.goindex aa374572a7..434349fffb 100644--- a/backend/store/plan_check_run.go+++ b/backend/store/plan_check_run.go@@ -39,6 +39,10 @@ type PlanCheckRunMessage struct {Status PlanCheckRunStatusResult *storepb.PlanCheckRunResult+ // Generation is the PostgreSQL row-version token. It changes whenever the+ // durable check row changes, including a same-version rerun that preserves+ // the row UID.+ Generation int64}// FindPlanCheckRunMessage is the message for finding plan check runs.@@ -119,7 +123,8 @@ func (s *Store) ListPlanCheckRuns(ctx context.Context, find *FindPlanCheckRunMesplan_check_run.project,plan_check_run.plan_id,plan_check_run.status,- plan_check_run.result+ plan_check_run.result,+ plan_check_run.xmin::text::bigintFROM plan_check_runWHERE TRUE`)if v := find.ProjectID; v != "" {@@ -176,6 +181,7 @@ func (s *Store) ListPlanCheckRuns(ctx context.Context, find *FindPlanCheckRunMes&planCheckRun.PlanUID,&planCheckRun.Status,&result,+ &planCheckRun.Generation,); err != nil {return nil, err}diff --git a/backend/store/task.go b/backend/store/task.goindex 8c9b0e508a..54c6dc6425 100644--- a/backend/store/task.go+++ b/backend/store/task.go@@ -78,21 +78,6 @@ type TaskStatusCount struct {Count int32}-// ErrDraftIssueNotSubmitted indicates rollout creation was rejected because its-// currently linked issue is still a draft.-var ErrDraftIssueNotSubmitted = errors.New("draft issue must be submitted before rollout creation")--// IssueApprovalGuard carries the approval-input version used for rollout-// creation. When issue approval is required, it also carries the issue approval-// snapshot that the API layer has already accepted. The store uses it only as a-// race guard: the plan must still be on this version and, when Approval is set,-// the locked issue row must still have the same approval payload.-type IssueApprovalGuard struct {- IssueUID int64- ApprovalInputVersion int64- Approval *storepb.IssuePayloadApproval-}-// GetTaskByID gets a task by ID.func (s *Store) GetTaskByID(ctx context.Context, projectID string, id int64) (*TaskMessage, error) {tasks, err := s.ListTasks(ctx, &TaskFind{ProjectID: projectID, ID: &id})@@ -510,115 +495,9 @@ func (s *Store) BatchSkipTasks(ctx context.Context, projectID string, taskUIDs [return nil}-// CreateRolloutTasks marks the plan as having rollout and creates tasks in one transaction.-// If issueApprovalGuard is set, the transaction creates no tasks unless the plan-// still has that approval input version. The API layer owns the "is this issue-// approved" policy check before calling this method; the store only verifies-// that the locked issue approval payload still matches the approved snapshot.-func (s *Store) CreateRolloutTasks(ctx context.Context, projectID string, planUID int64, issueApprovalGuard *IssueApprovalGuard, tasks []*TaskMessage) (bool, []*TaskMessage, error) {- tx, err := s.GetDB().BeginTx(ctx, nil)- if err != nil {- return false, nil, errors.Wrapf(err, "failed to begin tx")- }- defer tx.Rollback()-- if err := acquirePlanIssueRolloutAdvisoryLock(ctx, tx, projectID, planUID); err != nil {- return false, nil, errors.Wrap(err, "failed to acquire plan issue-rollout lock")- }-- var approvalInputVersion *int64- if issueApprovalGuard != nil {- approvalInputVersion = &issueApprovalGuard.ApprovalInputVersion- }-- var currentIssueUID int64- var payload []byte- issueFound := true- if err := tx.QueryRowContext(ctx, `- SELECT id, payload- FROM issue- WHERE project = $1- AND plan_id = $2- FOR UPDATE`,- projectID, planUID).Scan(¤tIssueUID, &payload); err != nil {- if errors.Is(err, sql.ErrNoRows) {- issueFound = false- } else {- return false, nil, errors.Wrap(err, "failed to lock linked issue")- }- }-- currentIssuePayload := &storepb.Issue{}- if issueFound {- if err := common.ProtojsonUnmarshaler.Unmarshal(payload, currentIssuePayload); err != nil {- return false, nil, errors.Wrap(err, "failed to unmarshal issue payload")- }- if currentIssuePayload.GetDraft() {- return false, nil, ErrDraftIssueNotSubmitted- }- }-- if issueApprovalGuard != nil && issueApprovalGuard.Approval != nil {- if !issueFound || currentIssueUID != issueApprovalGuard.IssueUID {- return false, nil, nil- }- if !isIssueApprovalPayloadSameAsGuard(currentIssuePayload, issueApprovalGuard) {- return false, nil, nil- }- }-- var updatedPlanUID int64- if err := tx.QueryRowContext(ctx, `- UPDATE plan- SET- updated_at = CASE- WHEN COALESCE((config->>'hasRollout')::boolean, false) = false THEN $1- ELSE updated_at- END,- config = CASE- WHEN COALESCE((config->>'hasRollout')::boolean, false) = false THEN jsonb_set(config, '{hasRollout}', 'true'::jsonb, true)- ELSE config- END- WHERE project = $2- AND id = $3- AND (- $4::bigint IS NULL- OR COALESCE((config->>'approvalInputVersion')::bigint, 0) = $4- )- RETURNING id`,- time.Now(), projectID, planUID, approvalInputVersion).Scan(&updatedPlanUID); err != nil {- if errors.Is(err, sql.ErrNoRows) {- return false, nil, nil- }- return false, nil, errors.Wrapf(err, "failed to mark plan has rollout")- }-- tasks, err = s.createTasksTxDedup(ctx, tx, projectID, planUID, tasks)- if err != nil {- return false, nil, err- }- if err := tx.Commit(); err != nil {- return false, nil, errors.Wrapf(err, "failed to commit tx")- }-- return true, tasks, nil-}--func isIssueApprovalPayloadSameAsGuard(issuePayload *storepb.Issue, guard *IssueApprovalGuard) bool {- if issuePayload == nil || guard == nil || guard.Approval == nil {- return false- }- if guard.Approval.GetApprovalInputVersion() != guard.ApprovalInputVersion {- return false- }- approval := issuePayload.GetApproval()- if approval == nil || !approval.GetApprovalFindingDone() {- return false- }- return approval.Equal(guard.Approval)-}--func (s *Store) createTasksTxDedup(ctx context.Context, tx *sql.Tx, projectID string, planUID int64, tasks []*TaskMessage) ([]*TaskMessage, error) {+// CreateMissingTasksTx creates any missing rollout tasks inside a caller-owned transaction.+// Review policy and Plan state transitions belong to the review module.+func (s *Store) CreateMissingTasksTx(ctx context.Context, tx *sql.Tx, projectID string, planUID int64, tasks []*TaskMessage) ([]*TaskMessage, error) {// Check existing tasks to avoid duplicatesexistingTasks, err := s.listTasksImpl(ctx, tx, &TaskFind{ProjectID: projectID,diff --git a/backend/tests/approval_test.go b/backend/tests/approval_test.goindex 9707d386c7..2662c8c70a 100644--- a/backend/tests/approval_test.go+++ b/backend/tests/approval_test.go@@ -15,6 +15,7 @@ import ("google.golang.org/protobuf/types/known/fieldmaskpb""github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/component/review"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/store"@@ -445,11 +446,14 @@ func createStaleApprovalInputVersionIssue(ctx context.Context, t *testing.T, ctlplan, err := stores.GetPlan(ctx, &store.FindPlanMessage{ProjectID: projectID, UID: &planUID})require.NoError(t, err)require.NotNil(t, plan)- _, err = stores.UpdatePlan(ctx, &store.UpdatePlanMessage{- UID: plan.UID,- ProjectID: plan.ProjectID,- Config: proto.CloneOf(plan.Config),- BumpApprovalInputVersion: true,+ storeProject, err := stores.GetProjectByResourceID(ctx, projectID)+ require.NoError(t, err)+ require.NotNil(t, storeProject)+ _, err = review.NewWorkflow(stores).UpdatePlanSpecs(ctx, review.UpdatePlanSpecsInput{+ Workspace: storeProject.Workspace,+ PlanUID: plan.UID,+ ProjectID: plan.ProjectID,+ Specs: proto.CloneOf(plan.Config).GetSpecs(),})require.NoError(t, err)diff --git a/backend/tests/cross_project_update_test.go b/backend/tests/cross_project_update_test.goindex 7f7698d6c5..377f761d50 100644--- a/backend/tests/cross_project_update_test.go+++ b/backend/tests/cross_project_update_test.go@@ -68,6 +68,24 @@ func TestCollisionUpdateIssueNoCrossProjectEffect(t *testing.T) {"project B's issue status leaked from project A update")}+// TestCollisionCreateRolloutIsolation verifies that the review module's+// transactional Plan/task writes stay scoped to the full project/ID keys.+func TestCollisionCreateRolloutIsolation(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)+ defer cancel()+ ctl := &controller{}+ ctx, err := ctl.StartServerWithExternalPg(ctx)+ a.NoError(err)+ defer ctl.Close(ctx)++ fixture := setupCollidingProjects(ctx, t, ctl)+ fixture.completeRolloutB(ctx, t, ctl)+ aAfter := snapshotProject(ctx, t, ctl, fixture.ProjectA)+ assertProjectUnchanged(t, fixture.BaselineA, aAfter, "project A after project B rollout")+}+// TestCollisionListPlansIsolation verifies that ListPlans scoped to project A// does not leak project B's plans.func TestCollisionListPlansIsolation(t *testing.T) {diff --git a/backend/tests/plan_audit_collision_test.go b/backend/tests/plan_audit_collision_test.goindex b95b62dfe5..57475a2807 100644--- a/backend/tests/plan_audit_collision_test.go+++ b/backend/tests/plan_audit_collision_test.go@@ -84,3 +84,30 @@ func TestCollision_PlanSpecAuditEmission(t *testing.T) {afterB := snapshotProject(ctx, t, ctl, fixture.ProjectB)assertProjectUnchanged(t, beforeB, afterB, "project B after plan A spec audit emission")}++// TestCollision_PlanMetadataUpdate verifies the ordinary Store.UpdatePlan path+// remains scoped by the full (project, id) key.+func TestCollision_PlanMetadataUpdate(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)+ defer cancel()+ ctl := &controller{}+ ctx, err := ctl.StartServerWithExternalPg(ctx)+ a.NoError(err)+ defer ctl.Close(ctx)++ fixture := setupCollidingProjects(ctx, t, ctl)+ beforeB := snapshotProject(ctx, t, ctl, fixture.ProjectB)+ updated, err := ctl.planServiceClient.UpdatePlan(ctx, connect.NewRequest(&v1pb.UpdatePlanRequest{+ Plan: &v1pb.Plan{+ Name: fixture.PlanA.Name,+ Title: "updated only in project A",+ },+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title"}},+ }))+ a.NoError(err)+ a.Equal("updated only in project A", updated.Msg.Title)+ afterB := snapshotProject(ctx, t, ctl, fixture.ProjectB)+ assertProjectUnchanged(t, beforeB, afterB, "project B after plan A metadata update")+}diff --git a/backend/tests/webhook_test.go b/backend/tests/webhook_test.goindex 2f58a1fbcd..542d3eeeda 100644--- a/backend/tests/webhook_test.go+++ b/backend/tests/webhook_test.go@@ -682,7 +682,7 @@ func TestWebhookIntegration(t *testing.T) {// Issue creator (default ctl token) re-requests approval. Note: RequestIssue// does NOT reset ApprovalFindingDone, so waitForIssuePending would return// immediately. Wait for the second "Approval required" webhook instead —- // RequestIssue calls approval.NotifyApprovalRequested directly.+ // RequestIssue dispatches the review workflow's approval-requested event.requestIssueAsCreator(ctx, t, ctl, issue, "addressed feedback")waitForWebhookCount(t, collector, project.Name, "Approval required", 2)diff --git a/docs/superpowers/plans/2026-07-03-approval-cel-issue-labels.md b/docs/superpowers/plans/2026-07-03-approval-cel-issue-labels.mdindex d7289efaf1..85e2788d3e 100644--- a/docs/superpowers/plans/2026-07-03-approval-cel-issue-labels.md+++ b/docs/superpowers/plans/2026-07-03-approval-cel-issue-labels.md@@ -457,10 +457,15 @@ require.EqualValues(t, 2, got.Payload.GetApproval().GetApprovalInputVersion())The post-rollout assertion must mark the plan as rolled out by calling:```go-approvalInputVersion := int64(2)-marked, _, err := stores.CreateRolloutTasks(ctx, "project-a", plan.UID, &approvalInputVersion, nil)+_, err := review.NewWorkflow(stores).CreateRollout(ctx, review.CreateRolloutInput{+ Workspace: "default",+ ProjectID: "project-a",+ PlanUID: plan.UID,+ BuildTasks: func(context.Context, *store.PlanMessage, *store.ProjectMessage) ([]*store.TaskMessage, error) {+ return nil, nil+ },+})require.NoError(t, err)-require.True(t, marked)```Then update labels and assert: