Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
package v1
import (
"context"
"fmt"
"log/slog"
"maps"
"slices"
"strings"
"time"
"connectrpc.com/connect"
"github.com/google/cel-go/cel"
celast "github.com/google/cel-go/common/ast"
celoperators "github.com/google/cel-go/common/operators"
"github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common"
"github.com/bytebase/bytebase/backend/common/log"
"github.com/bytebase/bytebase/backend/common/permission"
"github.com/bytebase/bytebase/backend/component/bus"
"github.com/bytebase/bytebase/backend/component/config"
"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/store"
"github.com/bytebase/bytebase/backend/utils"
)
// IssueService implements the issue service.
type IssueService struct {
v1connect.UnimplementedIssueServiceHandler
store *store.Store
webhookManager *webhook.Manager
bus *bus.Bus
licenseService *enterprise.LicenseService
iamManager *iam.Manager
profile *config.Profile
reviewWorkflow *review.Workflow
}
// NewIssueService creates a new IssueService.
func NewIssueService(
store *store.Store,
webhookManager *webhook.Manager,
bus *bus.Bus,
licenseService *enterprise.LicenseService,
iamManager *iam.Manager,
profile *config.Profile,
) *IssueService {
return &IssueService{
store: store,
webhookManager: webhookManager,
bus: bus,
licenseService: licenseService,
iamManager: iamManager,
profile: profile,
reviewWorkflow: review.NewWorkflow(store),
}
}
// GetIssue gets a issue.
func (s *IssueService) GetIssue(ctx context.Context, req *connect.Request[v1pb.GetIssueRequest]) (*connect.Response[v1pb.Issue], error) {
issue, err := s.getIssueMessage(ctx, req.Msg.Name)
if err != nil {
return nil, 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
}
// getIssueFind translates the CEL filter into a store query. It returns the user
// named by `current_approver`, if any: their roles depend on the projects being
// searched, which the caller resolves afterwards via setNextApproverRoles.
func (s *IssueService) getIssueFind(
ctx context.Context,
filter string,
query string,
limit,
offset *int,
) (*store.FindIssueMessage, *store.UserMessage, error) {
issueFind := &store.FindIssueMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
Limit: limit,
Offset: offset,
}
if query != "" {
issueFind.Query = &query
}
if filter == "" {
return issueFind, nil, nil
}
ast, err := common.ParseCELFilter(filter)
if err != nil {
return nil, nil, connect.NewError(connect.CodeInvalidArgument, err)
}
var approver *store.UserMessage
var parseFilter func(expr celast.Expr) (string, error)
parseFilter = func(expr celast.Expr) (string, error) {
switch expr.Kind() {
case celast.CallKind:
functionName := expr.AsCall().FunctionName()
switch functionName {
case celoperators.LogicalAnd:
return getSubConditionFromExpr(expr, parseFilter, "AND")
case celoperators.Equals:
variable, value := getVariableAndValueFromExpr(expr)
switch variable {
case "status":
issueStatus, err := convertToAPIIssueStatus(v1pb.IssueStatus(v1pb.IssueStatus_value[value.(string)]))
if err != nil {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to issue status, err: %v", err))
}
issueFind.StatusList = append(issueFind.StatusList, issueStatus)
case "type":
issueType, err := convertToAPIIssueType(v1pb.Issue_Type(v1pb.Issue_Type_value[value.(string)]))
if err != nil {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to issue type, err: %v", err))
}
issueFind.Types = &[]storepb.Issue_Type{issueType}
case "labels":
issueFind.LabelList = append(issueFind.LabelList, value.(string))
case "approval_status":
approvalStatusValue, ok := v1pb.ApprovalStatus_value[value.(string)]
if !ok {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf(`invalid approval_status %q`, value))
}
issueFind.ApprovalStatus = new(v1pb.ApprovalStatus(approvalStatusValue).String())
case "current_approver", "creator":
user, err := s.getUserByIdentifier(ctx, value.(string))
if err != nil {
return "", connect.NewError(connect.CodeInternal, errors.Errorf("failed to get user %v with error %v", value, err.Error()))
}
if variable == "current_approver" {
approver = user
} else {
issueFind.CreatorID = &user.Email
}
default:
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupport variable %q with %v operator", variable, celoperators.Equals))
}
case celoperators.GreaterEquals, celoperators.LessEquals:
variable, rawValue := getVariableAndValueFromExpr(expr)
value, ok := rawValue.(string)
if !ok {
return "", errors.Errorf("expect string, got %T, hint: filter literals should be string", rawValue)
}
if variable != "create_time" {
return "", errors.Errorf(`">=" and "<=" are only supported for "create_time"`)
}
t, err := time.Parse(time.RFC3339, value)
if err != nil {
return "", errors.Errorf("failed to parse time %v, error: %v", value, err)
}
if functionName == celoperators.GreaterEquals {
issueFind.CreatedAtAfter = &t
} else {
issueFind.CreatedAtBefore = &t
}
case celoperators.In:
variable, value := getVariableAndValueFromExpr(expr)
rawList, ok := value.([]any)
if !ok {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid list value %q for %v", value, variable))
}
if len(rawList) == 0 {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("empty list value for filter %v", variable))
}
switch variable {
case "status":
for _, raw := range rawList {
newStatus, err := convertToAPIIssueStatus(v1pb.IssueStatus(v1pb.IssueStatus_value[raw.(string)]))
if err != nil {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to issue status, err: %v", err))
}
issueFind.StatusList = append(issueFind.StatusList, newStatus)
}
case "type":
var types []storepb.Issue_Type
for _, raw := range rawList {
issueType, err := convertToAPIIssueType(v1pb.Issue_Type(v1pb.Issue_Type_value[raw.(string)]))
if err != nil {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to issue type, err: %v", err))
}
types = append(types, issueType)
}
issueFind.Types = &types
case "labels":
for _, label := range rawList {
issueLabel, ok := label.(string)
if !ok {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf(`label should be string`))
}
issueFind.LabelList = append(issueFind.LabelList, issueLabel)
}
case "risk_level":
for _, raw := range rawList {
riskLevel, err := convertToAPIRiskLevel(v1pb.RiskLevel(v1pb.RiskLevel_value[raw.(string)]))
if err != nil {
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to risk level, err: %v", err))
}
issueFind.RiskLevelList = append(issueFind.RiskLevelList, riskLevel)
}
default:
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupport variable %q with %v operator", variable, celoperators.In))
}
default:
return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupported function %q", functionName))
}
default:
return "", errors.Errorf("unexpected expr kind %v", expr.Kind())
}
return "", nil
}
if _, err := parseFilter(ast.NativeRep().Expr()); err != nil {
return nil, nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse filter"))
}
return issueFind, approver, nil
}
// setNextApproverRoles resolves the roles the approver holds in each project
// being searched, so `current_approver` can be matched in SQL.
func (s *IssueService) setNextApproverRoles(ctx context.Context, issueFind *store.FindIssueMessage, approver *store.UserMessage) error {
if approver == nil {
return nil
}
workspaceID := common.GetWorkspaceIDFromContext(ctx)
workspacePolicy, err := s.store.GetWorkspaceIamPolicy(ctx, workspaceID)
if err != nil {
return errors.Wrapf(err, "failed to get workspace iam policy")
}
// One query rather than one per project: the wildcard search authorizes
// every project the caller can read issues in, and a workspace-level
// grant reaches this loop without having read any project policy.
projectPolicies, err := s.store.ListProjectIamPolicies(ctx, workspaceID, issueFind.ProjectIDs)
if err != nil {
return errors.Wrapf(err, "failed to list project iam policies")
}
// Resolved once rather than per project. GetUserRolesInIamPolicy unions the
// policies it is handed, so roles(workspace ∪ project) is roles(workspace)
// ∪ roles(project) and splitting the two changes nothing — but expanding
// the workspace policy inside the loop re-runs its group lookups for every
// project, and HA runs with the store cache off (server.go passes
// !profile.HA), so each of those is a real query.
workspaceRoles := utils.GetUserFormattedRolesMap(ctx, s.store, workspaceID, approver, workspacePolicy.Policy)
projectRoles := []store.ProjectRole{}
for _, projectID := range issueFind.ProjectIDs {
roles := map[string]bool{}
maps.Copy(roles, workspaceRoles)
if projectPolicy, ok := projectPolicies[projectID]; ok {
maps.Copy(roles, utils.GetUserFormattedRolesMap(ctx, s.store, workspaceID, approver, projectPolicy))
}
for role := range roles {
projectRoles = append(projectRoles, store.ProjectRole{ProjectID: projectID, Role: role})
}
}
issueFind.NextApproverRoles = &projectRoles
return nil
}
func (s *IssueService) ListIssues(ctx context.Context, req *connect.Request[v1pb.ListIssuesRequest]) (*connect.Response[v1pb.ListIssuesResponse], error) {
if req.Msg.PageSize < 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("page size must be non-negative: %d", req.Msg.PageSize))
}
projectID, err := common.GetProjectID(req.Msg.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
offset, err := parseLimitAndOffset(&pageSize{
token: req.Msg.PageToken,
limit: int(req.Msg.PageSize),
maximum: 1000,
})
if err != nil {
return nil, err
}
limitPlusOne := offset.limit + 1
issueFind, approver, err := s.getIssueFind(ctx, req.Msg.Filter, req.Msg.Query, &limitPlusOne, &offset.offset)
if err != nil {
return nil, err
}
issueFind.ProjectIDs = []string{projectID}
issueFind.ExcludeDraft = true
if err := s.setNextApproverRoles(ctx, issueFind, approver); err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
orderByKeys, err := store.GetIssueOrders(req.Msg.OrderBy)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
issueFind.OrderByKeys = orderByKeys
issues, err := s.store.ListIssues(ctx, issueFind)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to search issue"))
}
var nextPageToken string
if len(issues) == limitPlusOne {
if nextPageToken, err = offset.getNextPageToken(); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get next page token"))
}
issues = issues[:offset.limit]
}
converted, err := s.convertToIssues(issues)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to issue"))
}
return connect.NewResponse(&v1pb.ListIssuesResponse{
Issues: converted,
NextPageToken: nextPageToken,
}), nil
}
func (s *IssueService) SearchIssues(ctx context.Context, req *connect.Request[v1pb.SearchIssuesRequest]) (*connect.Response[v1pb.SearchIssuesResponse], error) {
if req.Msg.PageSize < 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("page size must be non-negative: %d", req.Msg.PageSize))
}
projectID, err := common.GetProjectID(req.Msg.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
offset, err := parseLimitAndOffset(&pageSize{
token: req.Msg.PageToken,
limit: int(req.Msg.PageSize),
maximum: 1000,
})
if err != nil {
return nil, err
}
limitPlusOne := offset.limit + 1
issueFind, approver, err := s.getIssueFind(ctx, req.Msg.Filter, req.Msg.Query, &limitPlusOne, &offset.offset)
if err != nil {
return nil, err
}
orderByKeys, err := store.GetIssueOrders(req.Msg.OrderBy)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
issueFind.OrderByKeys = orderByKeys
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
// This RPC uses CUSTOM auth, so the ACL interceptor performs no permission
// check: both branches below must authorize the read themselves.
var projectIDs []string
if projectID == "-" {
// AIP-159 wildcard: search across every project where the caller holds
// the permission. An empty set makes the store return zero rows.
projectIDsFilter, err := getProjectIDsSearchFilter(ctx, user, permission.IssuesGet, s.iamManager, s.store)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get projectIDs"))
}
if projectIDsFilter != nil {
projectIDs = *projectIDsFilter
}
} else {
// Resolve the project first so an unknown parent is a NotFound rather
// than an INTERNAL out of CheckPermission's own project lookup. This
// matches what the ACL interceptor does for the IAM-authorized RPCs.
project, err := s.store.GetProject(ctx, &store.FindProjectMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
ResourceID: &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 not found for id: %v", projectID))
}
ok, err := s.iamManager.CheckPermission(ctx, permission.IssuesGet, user, common.GetWorkspaceIDFromContext(ctx), projectID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check permission %q", permission.IssuesGet))
}
if !ok {
return nil, permissionDeniedError(ctx, errors.Errorf("user does not have permission %q in %q", permission.IssuesGet, req.Msg.Parent))
}
projectIDs = append(projectIDs, projectID)
}
issueFind.ProjectIDs = projectIDs
issueFind.ExcludeDraft = true
if err := s.setNextApproverRoles(ctx, issueFind, approver); err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
issues, err := s.store.ListIssues(ctx, issueFind)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to search issue"))
}
var nextPageToken string
if len(issues) == limitPlusOne {
if nextPageToken, err = offset.getNextPageToken(); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get next page token"))
}
issues = issues[:offset.limit]
}
converted, err := s.convertToIssues(issues)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to issue"))
}
return connect.NewResponse(&v1pb.SearchIssuesResponse{
Issues: converted,
NextPageToken: nextPageToken,
}), nil
}
func (s *IssueService) getUserByIdentifier(ctx context.Context, identifier string) (*store.UserMessage, error) {
email := strings.TrimPrefix(identifier, "users/")
if email == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid empty creator identifier"))
}
account, err := s.store.GetAccountByEmail(ctx, email)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf(`failed to find user "%s" with error: %v`, email, err.Error()))
}
if account == nil {
return nil, errors.Errorf("cannot found user %s", email)
}
return &store.UserMessage{
Email: account.Email,
Name: account.Name,
Type: account.Type,
MemberDeleted: account.MemberDeleted,
}, nil
}
// CreateIssue creates a issue.
func (s *IssueService) CreateIssue(ctx context.Context, req *connect.Request[v1pb.CreateIssueRequest]) (*connect.Response[v1pb.Issue], error) {
if err := rejectMCPOriginatedGrantIssue(ctx, req.Msg.GetIssue().GetType()); err != nil {
return nil, err
}
projectID, err := common.GetProjectID(req.Msg.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
project, err := s.store.GetProject(ctx, &store.FindProjectMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
ResourceID: &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 not found for id: %v", projectID))
}
issueLabels := store.CanonicalizeIssueLabels(req.Msg.Issue.Labels)
if !req.Msg.Issue.GetDraft() && project.Setting.ForceIssueLabels && len(issueLabels) == 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("require issue labels"))
}
// enforceIssueTitle is enforced on CreatePlan (plan.Name is gated there). Issues
// with empty Title inherit plan.Name via buildIssueMessage; ROLE_GRANT issues
// have their own title-required check below. No gate needed here.
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
issue, err := s.buildIssueMessage(ctx, project, user.Email, req.Msg, issueLabels)
if err != nil {
return nil, err
}
created := false
issueToCreate := issue
if issueToCreate.Payload.GetDraft() {
result, err := s.reviewWorkflow.CreateDraftIssue(ctx, review.CreateDraftIssueInput{
Workspace: common.GetWorkspaceIDFromContext(ctx),
Issue: issueToCreate,
})
if err != nil {
return nil, mapDraftCreationError(err)
}
issue = result.Issue
created = result.Created
} else {
existing, err := s.findLinkedIssueForCreate(ctx, issueToCreate)
if err != nil {
return nil, err
}
if existing != nil {
issue = existing
} else {
issue, err = s.store.CreateIssue(ctx, issueToCreate)
if err != nil {
existing, lookupErr := s.findLinkedIssueForCreate(ctx, issueToCreate)
if lookupErr != nil {
return nil, lookupErr
}
if existing == nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create issue"))
}
issue = existing
} else {
created = true
}
}
}
// The reviews start before the workflow, whose approval check can create
// the rollout: a rule slot already in place holds it until that review is
// done.
if created {
startReviews(ctx, s.profile, s.store, s.bus, issue, store.ReviewRunTypeRule, store.ReviewRunTypeAI)
}
if created && !issue.Payload.GetDraft() {
issue, err = startIssueWorkflow(ctx, s.store, s.webhookManager, s.licenseService, s.bus, project, user.Name, user.Email, issue)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
}
converted, err := s.convertToIssue(issue)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to issue"))
}
return connect.NewResponse(converted), nil
}
func mapDraftCreationError(err error) 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.ErrorConflict:
return connect.NewError(connect.CodeAlreadyExists, workflowErr)
default:
return connect.NewError(connect.CodeInternal, workflowErr)
}
}
func (s *IssueService) findLinkedIssueForCreate(ctx context.Context, issue *store.IssueMessage) (*store.IssueMessage, error) {
if issue.Type != storepb.Issue_DATABASE_CHANGE || issue.PlanUID == nil {
return nil, nil
}
existing, err := s.store.GetIssue(ctx, &store.FindIssueMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
ProjectIDs: []string{issue.ProjectID},
PlanUID: issue.PlanUID,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to find issue by plan"))
}
return linkedIssueForCreate(*issue.PlanUID, existing, issue)
}
// linkedIssueForCreate decides what creating issue means when its plan,
// planUID, already has one. A submitted issue is final for the plan. A draft is the creator's
// own: the same creator asking again gets it back, a submission must go
// through it, and another creator is told the plan is taken.
func linkedIssueForCreate(planUID int64, existing, issue *store.IssueMessage) (*store.IssueMessage, error) {
if existing == nil {
return nil, nil
}
if !existing.Payload.GetDraft() {
return nil, connect.NewError(connect.CodeAlreadyExists, errors.Errorf("plan %d already has a non-draft issue", planUID))
}
if !issue.Payload.GetDraft() {
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("plan %d already has a draft issue; update or submit the existing draft instead of creating another issue", planUID))
}
if existing.CreatorEmail != issue.CreatorEmail {
return nil, connect.NewError(connect.CodeAlreadyExists, errors.Errorf("plan %d already has a draft issue", planUID))
}
return existing, nil
}
// rejectMCPOriginatedGrantIssue applies grantIssueRefusal where the issue is
// created, so it also covers UpdateIssue with allow_missing, which creates only
// when the issue is missing and so cannot be refused at the gate.
func rejectMCPOriginatedGrantIssue(ctx context.Context, issueType v1pb.Issue_Type) error {
if !mcpSession(ctx) {
return nil
}
reason, wayOut := grantIssueRefusal(issueType)
if reason == "" {
return nil
}
return permissionDeniedError(ctx, errors.Errorf("an MCP session may not create this issue: %s. %s", reason, wayOut))
}
func (s *IssueService) buildIssueMessage(ctx context.Context, project *store.ProjectMessage, userEmail string, request *v1pb.CreateIssueRequest, labels []string) (*store.IssueMessage, error) {
var planUID *int64
var roleGrant *storepb.RoleGrant
var title, description string
if request.Issue.GetDraft() && request.Issue.Type != v1pb.Issue_DATABASE_CHANGE {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("draft issues must be database change issues"))
}
// Type-specific validation and preparation
switch request.Issue.Type {
case v1pb.Issue_ROLE_GRANT:
// Title is required for role grant requests.
if strings.TrimSpace(request.Issue.Title) == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("issue title is required"))
}
// Check if role grant workflow feature is enabled.
if err := s.licenseService.IsFeatureEnabled(ctx, common.GetWorkspaceIDFromContext(ctx), v1pb.PlanFeature_FEATURE_REQUEST_ROLE_WORKFLOW); err != nil {
return nil, connect.NewError(connect.CodePermissionDenied,
errors.Errorf("role request requires approval workflow feature (available in Enterprise plan)"))
}
// Validate role grant fields.
if request.Issue.RoleGrant.GetRole() == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("expect role grant role"))
}
if request.Issue.RoleGrant.GetUser() == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("expect role grant user"))
}
// Validate CEL expression if it's not empty.
if expression := request.Issue.RoleGrant.GetCondition().GetExpression(); expression != "" {
e, err := cel.NewEnv(common.IAMPolicyConditionCELAttributes...)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create cel environment"))
}
if _, issues := e.Compile(expression); issues != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("found issues in role grant condition expression, issues: %v", issues.String()))
}
}
// Enforce the workspace maximum role expiration cap (project owner is
// exempt). The role grant's condition carries the
// `request.time < timestamp(...)` clause that becomes the IAM binding, so
// validating it here also rejects a missing expiration when a cap is set.
if request.Issue.RoleGrant.GetRole() != fmt.Sprintf("roles/%s", store.ProjectOwnerRole) {
workspaceProfileSetting, err := s.store.GetWorkspaceProfileSetting(ctx, common.GetWorkspaceIDFromContext(ctx))
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.New("failed to get workspace profile setting"))
}
if maximumRoleExpiration := workspaceProfileSetting.GetMaximumRoleExpiration(); maximumRoleExpiration != nil {
if err := validateExpirationInExpression(request.Issue.RoleGrant.GetCondition().GetExpression(), maximumRoleExpiration); err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to validate role expiration"))
}
}
}
roleGrantUserEmail, err := common.GetUserEmail(request.Issue.RoleGrant.User)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get user email from %q", request.Issue.RoleGrant.User))
}
roleGrantUser, err := s.store.GetUserByEmail(ctx, roleGrantUserEmail)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get user by email %q", roleGrantUserEmail))
}
if roleGrantUser == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("user %q not found", request.Issue.RoleGrant.User))
}
roleGrant = &storepb.RoleGrant{
Role: request.Issue.RoleGrant.Role,
User: common.FormatUserEmail(roleGrantUser.Email),
Condition: request.Issue.RoleGrant.Condition,
Expiration: request.Issue.RoleGrant.Expiration,
}
title = strings.TrimSpace(request.Issue.Title)
description = request.Issue.Description
case v1pb.Issue_DATABASE_CHANGE:
// Validate and fetch plan (shared logic for both types)
if request.Issue.Plan == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("plan is required"))
}
_, planID, err := common.GetProjectIDPlanID(request.Issue.Plan)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), UID: &planID, ProjectID: project.ResourceID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get plan"))
}
if plan == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %d not found in project %s", planID, project.ResourceID))
}
planUID = &plan.UID
// Use plan's title and description as defaults if not provided by request
title = strings.TrimSpace(request.Issue.Title)
if title == "" {
title = plan.Name
}
description = request.Issue.Description
if description == "" {
description = plan.Description
}
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unknown issue type %q", request.Issue.Type))
}
// Convert v1pb.Issue_Type to storepb.Issue_Type
issueType, err := convertToAPIIssueType(request.Issue.Type)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to convert issue type"))
}
// Build the issue message (common structure)
issue := &store.IssueMessage{
ProjectID: project.ResourceID,
CreatorEmail: userEmail,
PlanUID: planUID,
Title: title,
Status: storepb.Issue_OPEN,
Type: issueType,
Description: description,
Payload: &storepb.Issue{
RoleGrant: roleGrant,
Approval: &storepb.IssuePayloadApproval{
ApprovalFindingDone: false,
ApprovalTemplate: nil,
Approvers: nil,
},
Labels: labels,
Draft: request.Issue.GetDraft(),
},
}
return issue, nil
}
func (s *IssueService) getSubmittedIssueForApprovalAction(ctx context.Context, name string) (*store.IssueMessage, error) {
issue, err := s.getIssueMessage(ctx, name)
if err != nil {
return nil, err
}
if issue.Payload.GetDraft() {
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("draft issue must be submitted before approval actions are allowed"))
}
return issue, nil
}
// RetryIssueApproval re-runs approval-template finding for an issue stuck
// in CHECKING. The synchronous workflow-start path in `startIssueWorkflow`
// swallows errors (e.g. CEL evaluation failure against a malformed
// workspace approval rule), and there is no event-driven retry for
// non-DATABASE_CHANGE issue types — once stuck, only this RPC (or a
// direct DB edit) gets the issue back into a resolved state.
//
// Authorization mirrors `RequestIssue`: only the issue creator may
// retry. The action is a self-service for "my issue is stuck"; an
// operator who needs to unstick someone else's issue should fix the
// underlying workspace approval rule and (if necessary) ask the issue
// creator to click Retry.
//
// Idempotent: returns the existing issue unchanged when approval-finding
// has already completed.
func (s *IssueService) RetryIssueApproval(ctx context.Context, req *connect.Request[v1pb.RetryIssueApprovalRequest]) (*connect.Response[v1pb.Issue], error) {
issue, err := s.getSubmittedIssueForApprovalAction(ctx, req.Msg.Name)
if err != nil {
return nil, err
}
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))
}
if !canRequestIssue(issue.CreatorEmail, user) {
return nil, connect.NewError(connect.CodePermissionDenied, errors.New("only the issue creator can retry approval finding"))
}
approvalFindingCurrent := true
var plan *store.PlanMessage
if issue.Type == storepb.Issue_DATABASE_CHANGE && issue.PlanUID != nil {
plan, err = s.store.GetPlan(ctx, &store.FindPlanMessage{ProjectID: issue.ProjectID, UID: issue.PlanUID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get plan"))
}
if plan == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.New("plan not found"))
}
approvalFindingCurrent = issue.Payload.GetApproval().GetApprovalInputVersion() == plan.Config.GetApprovalInputVersion()
}
// No-op fast path: nothing to retry if the previous attempt completed for the current approval input.
if issue.Payload.GetApproval().GetApprovalFindingDone() && approvalFindingCurrent {
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
}
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{
Workspace: common.GetWorkspaceIDFromContext(ctx),
ProjectIDs: []string{issue.ProjectID},
UID: &uid,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to refresh issue"))
}
if refreshed == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.New("issue not found after retry"))
}
// Mirror the post-approval side effects that `postCreateIssue` and the
// approval runner perform when finding completes — without these, an
// auto-approved (template-less / SKIPPED) retry result would leave the
// issue out of CHECKING but skip the actual work:
// * ACCESS_GRANT / ROLE_GRANT → activate the grant via
// `completeAccessRequestIssue`.
// * DATABASE_CHANGE with a plan → enqueue rollout creation.
if plan == nil && refreshed.Type == storepb.Issue_DATABASE_CHANGE && refreshed.PlanUID != nil {
plan, err = s.store.GetPlan(ctx, &store.FindPlanMessage{ProjectID: refreshed.ProjectID, UID: refreshed.PlanUID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get plan"))
}
if plan == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.New("plan not found"))
}
}
approved, err := utils.CheckIssueApprovedForPlan(refreshed, plan)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to check approval state"))
}
if approved {
switch refreshed.Type {
case storepb.Issue_ACCESS_GRANT, storepb.Issue_ROLE_GRANT:
if completed, completeErr := completeAccessRequestIssue(ctx, s.store, user.Email, refreshed); completeErr != nil {
slog.Warn("failed to complete access request issue after retry", log.BBError(completeErr))
} else {
refreshed = completed
}
case storepb.Issue_DATABASE_CHANGE:
if refreshed.PlanUID != nil {
s.bus.RolloutCreationChan <- bus.PlanRef{ProjectID: refreshed.ProjectID, PlanID: *refreshed.PlanUID}
}
default:
}
}
issueV1, err := s.convertToIssue(refreshed)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to convert to issue"))
}
return connect.NewResponse(issueV1), nil
}
// UpdateIssue updates the issue.
func (s *IssueService) UpdateIssue(ctx context.Context, req *connect.Request[v1pb.UpdateIssueRequest]) (*connect.Response[v1pb.Issue], error) {
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
if req.Msg.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update_mask must be set"))
}
issue, err := s.getIssueMessage(ctx, req.Msg.Issue.Name)
if err != nil {
if connect.CodeOf(err) == connect.CodeNotFound && req.Msg.AllowMissing {
// When allow_missing is true and issue doesn't exist, create a new one
ok, err := s.iamManager.CheckPermission(ctx, permission.IssuesCreate, user, common.GetWorkspaceIDFromContext(ctx))
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to check permission"))
}
if !ok {
return nil, permissionDeniedError(ctx, errors.Errorf("user does not have permission %q", permission.IssuesCreate))
}
// Extract project ID from the issue name (format: projects/{project}/issues/{issue})
parts := strings.Split(req.Msg.Issue.Name, "/")
if len(parts) < 4 || parts[0] != "projects" || parts[2] != "issues" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid issue name format: %q", req.Msg.Issue.Name))
}
projectID := parts[1]
return s.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
Parent: fmt.Sprintf("projects/%s", projectID),
Issue: req.Msg.Issue,
}))
}
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))
}
submitting := false
labelsForSubmission := store.CanonicalizeIssueLabels(issue.Payload.GetLabels())
labelsSetForSubmission := false
for _, path := range req.Msg.UpdateMask.Paths {
switch path {
case "labels":
labelsForSubmission = store.CanonicalizeIssueLabels(req.Msg.Issue.Labels)
labelsSetForSubmission = true
case "draft":
if req.Msg.Issue.GetDraft() {
if !issue.Payload.GetDraft() {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("a submitted issue cannot be changed back to draft"))
}
} else if issue.Payload.GetDraft() {
submitting = true
}
default:
// Other update paths do not affect draft submission preparation.
}
}
expectedDraft := issue.Payload.GetDraft()
metadataInput := review.UpdateIssueMetadataInput{
Workspace: common.GetWorkspaceIDFromContext(ctx),
ProjectID: issue.ProjectID,
IssueUID: issue.UID,
ExpectedDraft: &expectedDraft,
}
hasMetadataPatch := false
var issueCommentCreates []*store.IssueCommentMessage
for _, path := range req.Msg.UpdateMask.Paths {
if issue.Payload.GetDraft() && (path == "title" || path == "description") {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("draft issue %s metadata must be updated through its Plan", req.Msg.Issue.Name))
}
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"))
}
metadataInput.Title = &trimmed
hasMetadataPatch = true
case "description":
metadataInput.Description = &req.Msg.Issue.Description
hasMetadataPatch = true
case "labels":
if !submitting {
labels := append([]string(nil), req.Msg.Issue.Labels...)
metadataInput.Labels = &labels
hasMetadataPatch = true
}
case "draft":
// Submission is committed below through the review workflow.
default:
// status moves through BatchUpdateIssuesStatus and approvals through
// ApproveIssue/RejectIssue, so those paths are not silently dropped
// here — they are not this method's to apply.
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf(`unsupported update_mask "%s"`, path))
}
}
if hasMetadataPatch {
result, err := s.reviewWorkflow.UpdateIssueMetadata(ctx, metadataInput)
if err != nil {
return nil, mapIssueSubmissionError(err)
}
issue = result.Issue
comments, approvalCheck, err := issueCommentsForMetadataEvents(issue.UID, result.Events)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
issueCommentCreates = append(issueCommentCreates, comments...)
if approvalCheck {
s.bus.ApprovalCheckChan <- bus.IssueRef{ProjectID: issue.ProjectID, UID: issue.UID}
}
}
var submissionResult *review.SubmitIssueResult
if submitting {
submissionResult, err = s.reviewWorkflow.SubmitIssue(ctx, review.SubmitIssueInput{
Workspace: common.GetWorkspaceIDFromContext(ctx),
ProjectID: issue.ProjectID,
IssueUID: issue.UID,
Labels: labelsForSubmission,
LabelsSet: labelsSetForSubmission,
})
if err != nil {
return nil, mapIssueSubmissionError(err)
}
issue = submissionResult.Issue
if submissionResult.LabelsChanged {
issueCommentCreates = append(issueCommentCreates, newIssueLabelsUpdateComment(issue.UID, submissionResult.PreviousLabels, labelsForSubmission))
}
}
for _, ic := range issueCommentCreates {
ic.ProjectID = issue.ProjectID
}
if _, err := s.store.CreateIssueComments(ctx, user.Email, issueCommentCreates...); err != nil {
slog.Warn("failed to create issue comments", "issue id", issue.UID, log.BBError(err))
}
if submissionResult != nil {
for _, event := range submissionResult.Events {
switch event.(type) {
case review.SubmittedEvent:
recordReviewSubmission(ctx, s.store, user.Email, issue)
case review.IssueCreatedEvent:
emitIssueCreated(ctx, s.webhookManager, submissionResult.Project, user.Name, user.Email, issue)
case review.ApprovalCheckEvent:
s.bus.ApprovalCheckChan <- bus.IssueRef{ProjectID: issue.ProjectID, UID: issue.UID}
default:
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("unexpected submission event %T", event))
}
}
}
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 newIssueLabelsUpdateComment(issueUID int64, fromLabels, toLabels []string) *store.IssueCommentMessage {
return &store.IssueCommentMessage{
IssueUID: issueUID,
Payload: &storepb.IssueCommentPayload{
Event: &storepb.IssueCommentPayload_IssueUpdate_{
IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{
FromLabels: fromLabels,
ToLabels: toLabels,
},
},
},
}
}
// issueCommentsForMetadataEvents turns the events a metadata patch produced
// into the audit comments the issue timeline shows, and reports whether the
// patch reset the approval, which is what asks for the approval check to run
// again. Which patches reset the approval is the review workflow's decision;
// this is only its record.
func issueCommentsForMetadataEvents(issueUID int64, events []review.Event) ([]*store.IssueCommentMessage, bool, error) {
var comments []*store.IssueCommentMessage
approvalCheck := false
for _, event := range events {
var update *storepb.IssueCommentPayload_IssueUpdate
switch event := event.(type) {
case review.IssueTitleUpdatedEvent:
update = &storepb.IssueCommentPayload_IssueUpdate{FromTitle: &event.FromTitle, ToTitle: &event.ToTitle}
case review.IssueDescriptionUpdatedEvent:
update = &storepb.IssueCommentPayload_IssueUpdate{FromDescription: &event.FromDescription, ToDescription: &event.ToDescription}
case review.IssueLabelsUpdatedEvent:
update = &storepb.IssueCommentPayload_IssueUpdate{FromLabels: event.FromLabels, ToLabels: event.ToLabels}
case review.ApprovalCheckEvent:
approvalCheck = true
continue
default:
return nil, false, errors.Errorf("unexpected issue metadata event %T", event)
}
comments = append(comments, &store.IssueCommentMessage{
IssueUID: issueUID,
Payload: &storepb.IssueCommentPayload{
Event: &storepb.IssueCommentPayload_IssueUpdate_{IssueUpdate: update},
},
})
}
return comments, approvalCheck, nil
}
func mapIssueSubmissionError(err error) 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:
return connect.NewError(connect.CodeAborted, workflowErr)
default:
return connect.NewError(connect.CodeInternal, workflowErr)
}
}
// 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)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
if len(req.Msg.Issues) == 0 {
return connect.NewResponse(&v1pb.BatchUpdateIssuesStatusResponse{}), nil
}
newStatus, err := convertToAPIIssueStatus(req.Msg.Status)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to convert to issue status, err: %v", err))
}
// Parse issue names and validate all issues belong to the same project.
var projectID string
issueUIDs := make([]int64, 0, len(req.Msg.Issues))
for i, issueName := range req.Msg.Issues {
issueProjectID, issueUID, err := common.GetProjectIDIssueUID(issueName)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid issue name %q: %v", issueName, err))
}
// Ensure all issues belong to the same project.
if i == 0 {
projectID = issueProjectID
} else if issueProjectID != projectID {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("all issues must belong to the same project, found %q and %q", projectID, issueProjectID))
}
issueUIDs = append(issueUIDs, issueUID)
}
// One comment per issue, and the store rejects a batch whose ids do not all
// resolve — so naming the same issue twice must collapse, not fail.
issueUIDs = slices.Compact(slices.Sorted(slices.Values(issueUIDs)))
// Get project early for webhooks.
project, err := s.store.GetProject(ctx, &store.FindProjectMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ResourceID: &projectID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get project: %v", err))
}
if project == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %q not found", projectID))
}
// Batch update issue statuses. This validates project membership, DONE status, and returns old statuses.
oldIssueStatuses, err := s.store.BatchUpdateIssueStatuses(ctx, projectID, issueUIDs, newStatus)
if err != nil {
if common.ErrorCode(err) == common.Invalid {
return nil, connect.NewError(connect.CodeFailedPrecondition, err)
}
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to batch update issues, err: %v", err))
}
// Batch create issue comments.
issueComments := make([]*store.IssueCommentMessage, 0, len(issueUIDs))
for _, issueUID := range issueUIDs {
issueComments = append(issueComments, &store.IssueCommentMessage{
ProjectID: projectID,
IssueUID: issueUID,
Payload: &storepb.IssueCommentPayload{
Comment: req.Msg.Reason,
Event: &storepb.IssueCommentPayload_IssueUpdate_{
IssueUpdate: &storepb.IssueCommentPayload_IssueUpdate{
FromStatus: new(oldIssueStatuses[issueUID]),
ToStatus: &newStatus,
},
},
},
})
}
if _, err := s.store.CreateIssueComments(ctx, user.Email, issueComments...); err != nil {
slog.Error("failed to batch create issue comments", log.BBError(err))
}
return connect.NewResponse(&v1pb.BatchUpdateIssuesStatusResponse{}), nil
}
func (s *IssueService) ListIssueComments(ctx context.Context, req *connect.Request[v1pb.ListIssueCommentsRequest]) (*connect.Response[v1pb.ListIssueCommentsResponse], error) {
if req.Msg.PageSize < 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("page size must be non-negative: %d", req.Msg.PageSize))
}
projectID, issueUID, err := common.GetProjectIDIssueUID(req.Msg.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
find, err := store.GetIssueCommentListFilter(req.Msg.Filter, projectID, issueUID)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
issue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
UID: &issueUID,
ProjectIDs: []string{projectID},
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get issue, err: %v", err))
}
if issue == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("issue %q not found", req.Msg.Parent))
}
offset, err := parseLimitAndOffset(&pageSize{
token: req.Msg.PageToken,
limit: int(req.Msg.PageSize),
maximum: 1000,
})
if err != nil {
return nil, err
}
limitPlusOne := offset.limit + 1
find.Limit = &limitPlusOne
find.Offset = &offset.offset
issueComments, err := s.store.ListIssueComment(ctx, find)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to list issue comments, err: %v", err))
}
var nextPageToken string
if len(issueComments) == limitPlusOne {
if nextPageToken, err = offset.getNextPageToken(); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get next page token"))
}
issueComments = issueComments[:offset.limit]
}
return connect.NewResponse(&v1pb.ListIssueCommentsResponse{
IssueComments: convertToIssueComments(req.Msg.Parent, issueComments),
NextPageToken: nextPageToken,
}), nil
}
// CreateIssueComment creates the issue comment.
func (s *IssueService) CreateIssueComment(ctx context.Context, req *connect.Request[v1pb.CreateIssueCommentRequest]) (*connect.Response[v1pb.IssueComment], error) {
if req.Msg.IssueComment.GetComment() == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("issue comment is empty"))
}
comment := req.Msg.IssueComment
// The store never sees the v1 event, so this is the one rule it cannot
// enforce; every thread invariant is the store's.
if comment.Event != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("events cannot be created through CreateIssueComment"))
}
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
issue, err := s.getIssueMessage(ctx, req.Msg.Parent)
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))
}
create := &store.IssueCommentMessage{
ProjectID: issue.ProjectID,
IssueUID: issue.UID,
Payload: &storepb.IssueCommentPayload{Comment: comment.Comment},
}
if comment.Root != nil {
p, uid, id, err := common.GetProjectIDIssueUIDIssueCommentID(comment.GetRoot())
if err != nil || p != issue.ProjectID || uid != issue.UID {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("root must name a comment in the same issue"))
}
create.ParentID = &id
}
if comment.ThreadState != nil {
state, err := convertToStoreThreadState(comment.GetThreadState())
if err != nil {
return nil, err
}
create.ThreadState = &state
}
if anchor := comment.StatementAnchor; anchor != nil {
if comment.Root == nil {
if err := s.validateStatementAnchorSpec(ctx, issue, anchor); err != nil {
return nil, err
}
}
if err := s.validateStatementAnchor(ctx, issue, anchor); err != nil {
return nil, err
}
create.Payload.StatementAnchor = &storepb.IssueCommentPayload_StatementAnchor{
SpecId: anchor.Spec,
SheetSha256: anchor.SheetSha256,
}
if anchor.StartPosition != nil {
create.Payload.StatementAnchor.StartPosition = &storepb.Position{Line: anchor.StartPosition.Line, Column: anchor.StartPosition.Column}
}
if anchor.EndPosition != nil {
create.Payload.StatementAnchor.EndPosition = &storepb.Position{Line: anchor.EndPosition.Line, Column: anchor.EndPosition.Column}
}
}
var ic *store.IssueCommentMessage
if create.ParentID != nil {
ic, err = s.store.CreateIssueCommentReply(ctx, user.Email, create)
// root is a request field, not the requested resource: a missing
// root is a bad request, not a missing parent.
if err != nil && common.ErrorCode(err) == common.NotFound {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
} else {
ic, err = s.store.CreateIssueComments(ctx, user.Email, create)
}
if err != nil {
return nil, issueCommentError(err)
}
return connect.NewResponse(convertToIssueComment(req.Msg.Parent, ic)), nil
}
// UpdateIssueComment updates the issue comment.
func (s *IssueService) UpdateIssueComment(ctx context.Context, req *connect.Request[v1pb.UpdateIssueCommentRequest]) (*connect.Response[v1pb.IssueComment], error) {
if len(req.Msg.UpdateMask.GetPaths()) == 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("update_mask is required"))
}
if req.Msg.IssueComment == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("issue_comment is required"))
}
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
parentProjectID, parentIssueUID, err := common.GetProjectIDIssueUID(req.Msg.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid parent %q: %v", req.Msg.Parent, err))
}
commentProjectID, commentIssueUID, issueCommentID, err := common.GetProjectIDIssueUIDIssueCommentID(req.Msg.IssueComment.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid comment name %q: %v", req.Msg.IssueComment.Name, err))
}
if parentProjectID != commentProjectID || parentIssueUID != commentIssueUID {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("issue comment %q does not belong to parent %q", req.Msg.IssueComment.Name, req.Msg.Parent))
}
issueComment, err := s.store.GetIssueComment(ctx, &store.FindIssueCommentMessage{ProjectID: parentProjectID, ResourceID: &issueCommentID, IssueUID: &parentIssueUID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get issue comment: %v", err))
}
if issueComment == nil {
if req.Msg.AllowMissing {
ok, err := s.iamManager.CheckPermission(ctx, permission.IssueCommentsCreate, user, common.GetWorkspaceIDFromContext(ctx))
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to check permission"))
}
if !ok {
return nil, permissionDeniedError(ctx, errors.Errorf("user does not have permission %q", permission.IssueCommentsCreate))
}
// Creation applies the complete resource regardless of the update mask.
return s.CreateIssueComment(ctx, connect.NewRequest(&v1pb.CreateIssueCommentRequest{
Parent: req.Msg.Parent,
IssueComment: req.Msg.IssueComment,
}))
}
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("issue comment not found"))
}
update := &store.UpdateIssueCommentMessage{
ProjectID: parentProjectID,
ResourceID: issueCommentID,
}
for _, path := range req.Msg.UpdateMask.Paths {
switch path {
case "comment":
if req.Msg.IssueComment.GetComment() == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("issue comment is empty"))
}
update.Comment = &req.Msg.IssueComment.Comment
case "thread_state":
if issueComment.ThreadState == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("only thread roots can be resolved or reopened"))
}
state, err := convertToStoreThreadState(req.Msg.IssueComment.GetThreadState())
if err != nil {
return nil, err
}
update.ThreadState = &state
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf(`unsupport update_mask: "%s"`, path))
}
}
if err := s.store.UpdateIssueComment(ctx, update); err != nil {
return nil, issueCommentError(err)
}
if s.profile.SQLReviewV2 && update.ThreadState != nil && *update.ThreadState == store.ThreadStateResolved {
requestRolloutCheck(ctx, s.store, s.bus, parentProjectID, parentIssueUID)
}
issueComment, err = s.store.GetIssueComment(ctx, &store.FindIssueCommentMessage{ProjectID: parentProjectID, ResourceID: &issueCommentID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get issue comment: %v", err))
}
if issueComment == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("issue comment not found"))
}
return connect.NewResponse(convertToIssueComment(req.Msg.Parent, issueComment)), nil
}
func (s *IssueService) getIssueMessage(ctx context.Context, name string) (*store.IssueMessage, error) {
projectID, issueUID, err := common.GetProjectIDIssueUID(name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
issue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
UID: &issueUID,
ProjectIDs: []string{projectID},
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get issue"))
}
if issue == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("issue %d not found in project %s", issueUID, projectID))
}
return issue, nil
}
func canRequestIssue(issueCreatorEmail string, user *store.UserMessage) bool {
return issueCreatorEmail == user.Email
}