Skip to content

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

refactor: centralize transactional issue review workflow (#20916)

p0ny4e0500b90bd7
diff --git a/backend/api/v1/issue_hook.go b/backend/api/v1/issue_hook.go
index 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 error
issue, 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.go
new file mode 100644
index 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.go
index 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.Bus
licenseService *enterprise.LicenseService
iamManager *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, n
return 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.Requ
return 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.UID
refreshed, err := s.store.GetIssue(ctx, &store.FindIssueMessage{
@@ -1212,118 +846,85 @@ func (s *IssueService) UpdateIssue(ctx context.Context, req *connect.Request[v1p
return 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 := false
var issueCommentCreates []*store.IssueCommentMessage
- var labelsChangedWithApprovalReset bool
- var labelsForApprovalReset []string
for _, path := range req.Msg.UpdateMask.Paths {
- updateMasks[path] = true
switch 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 = true
case "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 = true
case "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[v1p
return 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) (*store
return 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.go
index 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 TestCreateRolloutAndPendingTasksAllowsUnapprovedIssueWhenApprovalNotRequire
ApprovalInputVersion: 2,
},
},
- RequirePlanApprovalInputVersion: &approvalInputVersion,
})
require.NoError(t, err)
@@ -110,6 +333,38 @@ func TestCreateRolloutAndPendingTasksAllowsUnapprovedIssueWhenApprovalNotRequire
require.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.go
index 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.Manager
webhookManager *webhook.Manager
licenseService *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, w
iamManager: iamManager,
webhookManager: webhookManager,
licenseService: licenseService,
+ reviewWorkflow: review.NewWorkflow(store),
}
}
@@ -294,15 +295,11 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[v
return 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_Spec
var planCheckRunsTrigger bool
var databaseGroup *v1pb.DatabaseGroup
- var issueCommentCreates []*store.IssueCommentMessage
- var issueToReset *store.IssueMessage
for _, 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 bool
if 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[v
s.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.Requ
return 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.go
index 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},
- 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},
- 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.go
index 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_DONE
updatedIssue, 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.go
index 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 parsercontext
diff --git a/backend/component/review/approval.go b/backend/component/review/approval.go
new file mode 100644
index 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.go
similarity index 88%
rename from backend/runner/approval/runner.go
rename to backend/component/review/evaluator.go
index 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 review
import (
"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 retry
return
}
+ 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, nil
diff --git a/backend/runner/approval/runner_test.go b/backend/component/review/evaluator_test.go
similarity index 96%
rename from backend/runner/approval/runner_test.go
rename to backend/component/review/evaluator_test.go
index 73ddd382a9..de51c84a39 100644
--- a/backend/runner/approval/runner_test.go
+++ b/backend/component/review/evaluator_test.go
@@ -1,4 +1,4 @@
-package approval
+package review
import (
"context"
@@ -519,6 +519,7 @@ func TestFindApprovalTemplateForIssueSkipsDatabaseChangeAfterRolloutWhenApproval
Description: "",
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 TestFindApprovalTemplateForIssueCompletesAfterRolloutWhenApprovalNotRequire
Description: "",
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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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},
+ 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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},
+ 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,
+ },
+ 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"}},
+ },
+ 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},
+ 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},
+ 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},
+ 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{},
+ },
+ }},
+ },
+ 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{},
+ 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},
+ 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"}},
+ },
+ 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},
+ 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},
+ 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.go
index 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.Scheduler
planCheckScheduler *plancheck.Scheduler
schemaSyncer *schemasync.Syncer
- approvalRunner *approval.Runner
+ approvalRunner *review.Runner
notifyListener *notifylistener.Listener
dataCleaner *cleaner.DataCleaner
heartbeatRunner *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.go
index 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.go
index 18616265ee..e4d2351942 100644
--- a/backend/store/issue.go
+++ b/backend/store/issue.go
@@ -3,7 +3,6 @@ package store
import (
"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.Segmenter
if 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, pa
if 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, pa
v.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, pa
set.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.go
index c90e9f68cc..aa5c5c4e0b 100644
--- a/backend/store/plan.go
+++ b/backend/store/plan.go
@@ -2,7 +2,6 @@ package store
import (
"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) (*Plan
if 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.go
deleted file mode 100644
index 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"}},
- },
- 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"}},
- },
- 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"}},
- },
- 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},
- 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"}},
- },
- 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"}},
- },
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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},
- 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.go
index 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 PlanCheckRunStatus
Result *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 *FindPlanCheckRunMes
plan_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::bigint
FROM plan_check_run
WHERE 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.go
index 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(&currentIssueUID, &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 duplicates
existingTasks, err := s.listTasksImpl(ctx, tx, &TaskFind{
ProjectID: projectID,
diff --git a/backend/tests/approval_test.go b/backend/tests/approval_test.go
index 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, ctl
plan, 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.go
index 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.go
index 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.go
index 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.md
index 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: