Skip to content

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

6.6 KB
Raw Blame
package v1

import (
	"context"
	"log/slog"
	"time"

	"connectrpc.com/connect"
	"github.com/pkg/errors"

	"github.com/bytebase/bytebase/backend/api/auth"
	"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,
		ConfirmedUpdateTime: confirmedUpdateTime(ctx),
	})
	if err != nil {
		return nil, mapReviewError(ctx, 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
}

// confirmedUpdateTime returns the issue version an MCP confirmation applies
// to. The MCP gate has checked that it names this procedure and issue.
func confirmedUpdateTime(ctx context.Context) *time.Time {
	confirmed, ok := auth.MCPConfirmedDecisionFromContext(ctx)
	if !ok {
		return nil
	}
	return &confirmed.IssueUpdateTime
}

func mapReviewError(ctx context.Context, 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:
		// ApproveIssue and RejectIssue carry no permission option, so the
		// approver-role check is the method's only permission check. The other
		// two refusals with this code are a project self-approval setting and
		// an issue-ownership rule, which the design leaves unmarked.
		if workflowErr.Reason == review.ReasonApproverRoleRequired {
			return permissionDeniedError(ctx, workflowErr)
		}
		return connect.NewError(connect.CodePermissionDenied, workflowErr)
	case review.ErrorConflict:
		verb := "request issue"
		switch action {
		case review.ActionApprove:
			verb = "approve"
		case review.ActionReject:
			verb = "reject"
		case review.ActionRequest:
		default:
			return connect.NewError(connect.CodeInternal, errors.Errorf("unexpected review action %d", action))
		}
		cause := "approval finding is stale"
		if workflowErr.Reason == review.ReasonChangedSinceConfirmed {
			cause = "the issue changed after the decision was confirmed"
		}
		return connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("cannot %s because %s", verb, cause))
	default:
		return connect.NewError(connect.CodeInternal, workflowErr)
	}
}