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"
"log/slog"
"slices"
"strings"
"connectrpc.com/connect"
"github.com/pkg/errors"
"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/plancheck"
"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"
)
// PlanService represents a service for managing plan.
type PlanService struct {
v1connect.UnimplementedPlanServiceHandler
store *store.Store
bus *bus.Bus
iamManager *iam.Manager
webhookManager *webhook.Manager
licenseService *enterprise.LicenseService
profile *config.Profile
reviewWorkflow *review.Workflow
}
// NewPlanService returns a plan service instance.
func NewPlanService(store *store.Store, bus *bus.Bus, iamManager *iam.Manager, webhookManager *webhook.Manager, licenseService *enterprise.LicenseService, profile *config.Profile) *PlanService {
return &PlanService{
store: store,
bus: bus,
iamManager: iamManager,
webhookManager: webhookManager,
licenseService: licenseService,
profile: profile,
reviewWorkflow: review.NewWorkflow(store),
}
}
// GetPlan gets a plan.
func (s *PlanService) GetPlan(ctx context.Context, request *connect.Request[v1pb.GetPlanRequest]) (*connect.Response[v1pb.Plan], error) {
req := request.Msg
projectID, planID, err := common.GetProjectIDPlanID(req.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
UID: &planID,
ProjectID: projectID,
})
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, projectID))
}
convertedPlan, err := convertToPlan(ctx, s.store, plan)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to plan"))
}
return connect.NewResponse(convertedPlan), nil
}
// ListPlans lists plans.
func (s *PlanService) ListPlans(ctx context.Context, request *connect.Request[v1pb.ListPlansRequest]) (*connect.Response[v1pb.ListPlansResponse], error) {
req := request.Msg
projectID, err := common.GetProjectID(req.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
offset, err := parseLimitAndOffset(&pageSize{
token: req.PageToken,
limit: int(req.PageSize),
maximum: 1000,
})
if err != nil {
return nil, err
}
limitPlusOne := offset.limit + 1
find := &store.FindPlanMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
Limit: &limitPlusOne,
Offset: &offset.offset,
ProjectID: projectID,
ExcludeMalformedUIPlans: true,
}
if req.Filter != "" {
filterQ, err := store.GetListPlanFilter(req.Filter)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
find.FilterQ = filterQ
}
plans, err := s.store.ListPlans(ctx, find)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to list plans"))
}
var nextPageToken string
// has more pages
if len(plans) == limitPlusOne {
if nextPageToken, err = offset.getNextPageToken(); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get next page token"))
}
plans = plans[:offset.limit]
}
convertedPlans, err := convertToPlans(ctx, s.store, plans)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to plans"))
}
return connect.NewResponse(&v1pb.ListPlansResponse{
Plans: convertedPlans,
NextPageToken: nextPageToken,
}), nil
}
func getProjectIDsSearchFilter(ctx context.Context, user *store.UserMessage, permission permission.Permission, iamManager *iam.Manager, stores *store.Store) (*[]string, error) {
workspaceID := common.GetWorkspaceIDFromContext(ctx)
projects, err := stores.ListProjects(ctx, &store.FindProjectMessage{Workspace: workspaceID})
if err != nil {
return nil, errors.Wrapf(err, "failed to list projects")
}
ok, err := iamManager.CheckPermission(ctx, permission, user, workspaceID)
if err != nil {
return nil, errors.Wrapf(err, "failed to check permission %q", permission)
}
if ok {
projectIDs := make([]string, 0, len(projects))
for _, project := range projects {
projectIDs = append(projectIDs, project.ResourceID)
}
return &projectIDs, nil
}
var projectIDs []string
for _, project := range projects {
ok, err := iamManager.CheckPermission(ctx, permission, user, workspaceID, project.ResourceID)
if err != nil {
return nil, errors.Wrapf(err, "failed to check permission %q", permission)
}
if ok {
projectIDs = append(projectIDs, project.ResourceID)
}
}
return &projectIDs, nil
}
// CreatePlan creates a new plan.
func (s *PlanService) CreatePlan(ctx context.Context, request *connect.Request[v1pb.CreatePlanRequest]) (*connect.Response[v1pb.Plan], error) {
req := request.Msg
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.New("user not found"))
}
projectID, err := common.GetProjectID(req.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
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))
}
trimmedTitle := strings.TrimSpace(req.Plan.Title)
if project.Setting.EnforceIssueTitle && trimmedTitle == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("project %q requires a manual plan title (enforce_issue_title is enabled)", req.Parent))
}
// Validate plan specs
databaseGroup, err := validateSpecs(ctx, s.store, projectID, req.Plan.Specs)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to validate plan specs"))
}
planMessage := &store.PlanMessage{
ProjectID: projectID,
Name: trimmedTitle,
Description: req.Plan.Description,
Config: convertPlan(req.Plan),
}
plan, err := s.store.CreatePlan(ctx, planMessage, user.Email)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create plan"))
}
planCheckRun, err := getPlanCheckRunFromPlan(ctx, s.store, project, plan, databaseGroup)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get plan check run for plan"))
}
if planCheckRun != nil {
if _, err := s.store.CreatePlanCheckRun(ctx, planCheckRun); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create plan check run"))
}
}
// Tickle plan check scheduler.
s.bus.PlanCheckTickleChan <- 0
convertedPlan, err := convertToPlan(ctx, s.store, plan)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to plan"))
}
return connect.NewResponse(convertedPlan), nil
}
// UpdatePlan updates a plan.
func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[v1pb.UpdatePlanRequest]) (*connect.Response[v1pb.Plan], error) {
req := request.Msg
if req.UpdateMask == nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("update_mask must be set"))
}
if len(req.UpdateMask.Paths) == 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("update_mask must not be empty"))
}
user, ok := GetUserFromContext(ctx)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
projectID, planID, err := common.GetProjectIDPlanID(req.Plan.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
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 %q, err: %v", projectID, err))
}
if project == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %q not found", projectID))
}
oldPlan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{Workspace: common.GetWorkspaceIDFromContext(ctx), ProjectID: projectID, UID: &planID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan %q: %v", req.Plan.Name, err))
}
if oldPlan == nil {
if req.AllowMissing {
ok, err := s.iamManager.CheckPermission(ctx, permission.PlansCreate, user, common.GetWorkspaceIDFromContext(ctx), projectID)
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.PlansCreate))
}
return s.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
Parent: common.FormatProject(projectID),
Plan: req.Plan,
}))
}
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %q not found", req.Plan.Name))
}
if storePlanConfigHasRelease(oldPlan.Config) && slices.Contains(req.UpdateMask.Paths, "specs") {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("disallowed to update the plan specs because the plan is created from a release"))
}
// Disallow updating CREATE_DATABASE plan specs
if storePlanConfigHasCreateDatabase(oldPlan.Config) && slices.Contains(req.UpdateMask.Paths, "specs") {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("disallowed to update the plan specs for CREATE_DATABASE plans"))
}
ok, err = func() (bool, error) {
if oldPlan.Creator == user.Email {
return true, nil
}
return s.iamManager.CheckPermission(ctx, permission.PlansUpdate, user, common.GetWorkspaceIDFromContext(ctx), oldPlan.ProjectID)
}()
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to check permission"))
}
if !ok {
return nil, permissionDeniedError(ctx, errors.Errorf("permission denied to update plan"))
}
var title *string
var description *string
var deleted *bool
var specs []*storepb.PlanConfig_Spec
var lastPlanEditor *string
var planCheckRunsTrigger bool
var databaseGroup *v1pb.DatabaseGroup
for _, path := range req.UpdateMask.Paths {
switch path {
case "title":
trimmed := strings.TrimSpace(req.Plan.Title)
if project.Setting.EnforceIssueTitle && trimmed == "" {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("project %q requires a manual plan title (enforce_issue_title is enabled)", common.FormatProject(project.ResourceID)))
}
title = &trimmed
case "description":
description = new(req.Plan.Description)
case "state":
deleted = new(req.Plan.State == v1pb.State_DELETED)
case "specs":
if oldPlan.Config != nil && oldPlan.Config.GetHasRollout() {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("cannot update specs for plan that has a rollout"))
}
// Validate the new specs.
dg, err := validateSpecs(ctx, s.store, oldPlan.ProjectID, req.Plan.Specs)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to validate plan specs"))
}
databaseGroup = dg
// Convert and store new specs.
allSpecs := convertPlanSpecs(req.GetPlan().GetSpecs())
specs = allSpecs
// Trigger plan check runs.
planCheckRunsTrigger = true
editor := strings.ToLower(user.Email)
lastPlanEditor = &editor
default:
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid update_mask path %q", path))
}
}
var specsUpdate *[]*storepb.PlanConfig_Spec
if planCheckRunsTrigger {
specsUpdate = &specs
}
updateResult, err := s.reviewWorkflow.UpdatePlan(ctx, review.UpdatePlanInput{
Workspace: common.GetWorkspaceIDFromContext(ctx),
PlanUID: oldPlan.UID,
ProjectID: oldPlan.ProjectID,
Title: title,
Description: description,
Deleted: deleted,
Specs: specsUpdate,
LastPlanEditor: lastPlanEditor,
})
if err != nil {
var workflowErr *review.Error
if errors.As(err, &workflowErr) && workflowErr.Code == review.ErrorFailedPrecondition {
return nil, connect.NewError(connect.CodeFailedPrecondition, workflowErr)
}
if errors.As(err, &workflowErr) && workflowErr.Code == review.ErrorConflict {
return nil, connect.NewError(connect.CodeAborted, workflowErr)
}
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to update plan %q: %v", req.Plan.Name, err))
}
updatedPlan := updateResult.Plan
var planCheckRunCreated bool
if planCheckRunsTrigger {
planCheckRun, err := getPlanCheckRunFromPlan(ctx, s.store, project, updatedPlan, databaseGroup)
if err != nil {
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 {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create plan check run"))
}
planCheckRunCreated = created
}
}
// The reviews start before the plan checks and the approval check are
// signaled, as either can create the rollout: a rule slot already reset
// holds it until the rule review of the new SQL is done.
if planCheckRunsTrigger {
startReviews(ctx, s.profile, s.store, s.bus, updateResult.Issue, store.ReviewRunTypeRule, store.ReviewRunTypeAI)
}
if updatedIssue := updateResult.Issue; updateResult.ApprovalReset && updatedIssue != nil {
if updatedIssue.Type == storepb.Issue_DATABASE_CHANGE && planCheckRunsTrigger && !planCheckRunCreated {
s.bus.ApprovalCheckChan <- bus.IssueRef{ProjectID: updatedIssue.ProjectID, UID: updatedIssue.UID}
}
}
if planCheckRunCreated {
// Tickle plan check scheduler.
s.bus.PlanCheckTickleChan <- 0
}
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))
}
}
convertedPlan, err := convertToPlan(ctx, s.store, updatedPlan)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert to plan"))
}
return connect.NewResponse(convertedPlan), nil
}
// GetPlanCheckRun gets the plan check run for the plan.
func (s *PlanService) GetPlanCheckRun(ctx context.Context, request *connect.Request[v1pb.GetPlanCheckRunRequest]) (*connect.Response[v1pb.PlanCheckRun], error) {
req := request.Msg
projectID, planUID, err := common.GetProjectIDPlanIDFromPlanCheckRun(req.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
planCheckRun, err := s.store.GetPlanCheckRun(ctx, projectID, planUID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get plan check run"))
}
if planCheckRun == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan check run not found for plan %d", planUID))
}
converted := convertToPlanCheckRun(projectID, planUID, planCheckRun)
return connect.NewResponse(converted), nil
}
// startRuleReviewOfPlan starts the standard rule review of the plan's issue,
// if it has one. Rerunning the checks leaves the AI review alone: rerunning it
// costs model calls, so it has its own RunReview.
func (s *PlanService) startRuleReviewOfPlan(ctx context.Context, plan *store.PlanMessage) {
if !s.profile.SQLReviewV2 {
return
}
issue, err := s.store.GetIssue(ctx, &store.FindIssueMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
ProjectIDs: []string{plan.ProjectID},
PlanUID: &plan.UID,
})
if err != nil {
slog.Warn("failed to find the plan's issue for the standard rule review",
slog.String("project", plan.ProjectID),
slog.Int64("plan_id", plan.UID),
log.BBError(err))
return
}
startReviews(ctx, s.profile, s.store, s.bus, issue, store.ReviewRunTypeRule)
}
// 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
projectID, planID, err := common.GetProjectIDPlanID(req.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
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))
}
plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
UID: &planID,
ProjectID: projectID,
})
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 not found"))
}
if storePlanConfigHasRelease(plan.Config) {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("cannot run plan checks because plan %q has release", plan.Name))
}
// Once a rollout exists the plan is frozen; re-running checks produces the
// same result and is misleading. Match the frontend gate in
// PlanCheckSection.vue / ChecksSection.vue / IssueDetailChecks.tsx.
if plan.Config.GetHasRollout() {
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("cannot run plan checks because plan %q already has a rollout", plan.Name))
}
var databaseGroup *v1pb.DatabaseGroup
for _, spec := range plan.Config.GetSpecs() {
if c, ok := spec.Config.(*storepb.PlanConfig_Spec_ChangeDatabaseConfig); ok {
if len(c.ChangeDatabaseConfig.Targets) == 1 {
if _, _, err := common.GetProjectIDDatabaseGroupID(c.ChangeDatabaseConfig.Targets[0]); err == nil {
dg, err := getDatabaseGroupByName(ctx, s.store, c.ChangeDatabaseConfig.Targets[0], v1pb.DatabaseGroupView_DATABASE_GROUP_VIEW_FULL)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get database group %q: %v", c.ChangeDatabaseConfig.Targets[0], err))
}
if dg == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database group %q not found", c.ChangeDatabaseConfig.Targets[0]))
}
databaseGroup = dg
break
}
}
}
}
s.startRuleReviewOfPlan(ctx, plan)
planCheckRun, err := getPlanCheckRunFromPlan(ctx, s.store, project, plan, databaseGroup)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get plan check run for plan"))
}
if planCheckRun == nil {
return connect.NewResponse(&v1pb.RunPlanChecksResponse{}), nil
}
created, err := s.store.CreatePlanCheckRun(ctx, planCheckRun)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create plan check run"))
}
if !created {
return connect.NewResponse(&v1pb.RunPlanChecksResponse{}), nil
}
// Tickle plan check scheduler.
s.bus.PlanCheckTickleChan <- 0
return connect.NewResponse(&v1pb.RunPlanChecksResponse{}), nil
}
// CancelPlanCheckRun cancels the plan check run for a plan.
func (s *PlanService) CancelPlanCheckRun(ctx context.Context, request *connect.Request[v1pb.CancelPlanCheckRunRequest]) (*connect.Response[v1pb.CancelPlanCheckRunResponse], error) {
req := request.Msg
projectID, planUID, err := common.GetProjectIDPlanIDFromPlanCheckRun(req.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
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 find project"))
}
if project == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))
}
planCheckRun, err := s.store.GetPlanCheckRun(ctx, projectID, planUID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get plan check run"))
}
if planCheckRun == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan check run not found for plan %d", planUID))
}
if planCheckRun.Status != store.PlanCheckRunStatusRunning && planCheckRun.Status != store.PlanCheckRunStatusAvailable {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("plan check run is not running or available"))
}
approvalInputVersion := planCheckRun.Result.GetApprovalInputVersion()
// Update the status to canceled.
canceled, err := s.store.CancelPlanCheckRunIfApprovalInputVersion(ctx, projectID, planCheckRun.UID, approvalInputVersion)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to cancel plan check run"))
}
if !canceled {
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("cannot cancel because plan check run is stale"))
}
// Cancel in-flight plan check run if running.
if cancelFunc, ok := s.bus.RunningPlanCheckRunsCancelFunc.Load(bus.PlanCheckRunRef{ProjectID: projectID, UID: planCheckRun.UID, ApprovalInputVersion: approvalInputVersion}); ok {
cancelFunc.(context.CancelFunc)()
}
// Broadcast cancel signal to all replicas for HA.
if err := s.store.SendSignal(ctx, storepb.Signal_CANCEL_PLAN_CHECK_RUN, projectID, planCheckRun.UID, &approvalInputVersion); err != nil {
slog.Warn("failed to send cancel signal", log.BBError(err))
}
return connect.NewResponse(&v1pb.CancelPlanCheckRunResponse{}), nil
}
func validateSpecs(ctx context.Context, s *store.Store, projectID string, specs []*v1pb.Plan_Spec) (*v1pb.DatabaseGroup, error) {
if len(specs) == 0 {
return nil, errors.Errorf("the plan has zero spec")
}
configTypeCount := map[string]int{}
seenID := map[string]bool{}
var releaseCount, sheetCount int
var sheetSha256s []string
var releaseString string
var instanceTargets []string
var databaseGroups []string
seenDatabaseGroups := map[string]bool{}
var databaseNames []string
var databaseGroup *v1pb.DatabaseGroup
for _, spec := range specs {
id := spec.GetId()
if id == "" {
return nil, errors.Errorf("spec id cannot be empty")
}
if seenID[id] {
return nil, errors.Errorf("found duplicate spec id %v", id)
}
seenID[id] = true
switch config := spec.Config.(type) {
case *v1pb.Plan_Spec_CreateDatabaseConfig:
configTypeCount["create_database"]++
if target := config.CreateDatabaseConfig.Target; target != "" {
targetProjectID, _, err := common.GetInstanceResourceName(target)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid instance name %q: %v", target, err))
}
if targetProjectID != nil && *targetProjectID != projectID {
return nil, errors.Errorf("instance %q (project %q) does not belong to plan project %q", target, *targetProjectID, projectID)
}
instanceTargets = append(instanceTargets, target)
}
case *v1pb.Plan_Spec_ChangeDatabaseConfig:
configTypeCount["change_database"]++
var databaseTarget, databaseGroupTarget int
for _, target := range config.ChangeDatabaseConfig.Targets {
if targetProjectID, _, _, err := common.GetDatabaseResourceName(target); err == nil {
if targetProjectID != nil && *targetProjectID != projectID {
return nil, errors.Errorf("database %q (project %q) does not belong to plan project %q", target, *targetProjectID, projectID)
}
databaseTarget++
databaseNames = append(databaseNames, target)
} else if _, _, err := common.GetProjectIDDatabaseGroupID(target); err == nil {
databaseGroupTarget++
if !seenDatabaseGroups[target] {
databaseGroups = append(databaseGroups, target)
seenDatabaseGroups[target] = true
}
} else {
return nil, errors.Errorf("invalid target %v", target)
}
}
// Disallow mixing database and database group targets in the same spec.
if databaseTarget > 0 && databaseGroupTarget > 0 {
return nil, errors.Errorf("found databaseTarget and databaseGroupTarget, expect only one kind")
}
// Track if this spec uses release or sheet.
if config.ChangeDatabaseConfig.Release != "" {
releaseCount++
releaseString = config.ChangeDatabaseConfig.Release
}
if config.ChangeDatabaseConfig.Sheet != "" {
sheetCount++
if _, sha, err := common.GetProjectResourceIDSheetSha256(config.ChangeDatabaseConfig.Sheet); err == nil {
sheetSha256s = append(sheetSha256s, sha)
}
}
default:
return nil, errors.Errorf("invalid spec type")
}
}
if len(configTypeCount) > 1 {
return nil, errors.Errorf("plan contains multiple types of spec configurations (%v), but each plan must contain only one type", len(configTypeCount))
}
// Disallow mixing ChangeDatabaseConfig specs with release and sheet.
if releaseCount > 0 && sheetCount > 0 {
return nil, errors.Errorf("plan contains both release and sheet based change database configs, but each plan must use only one approach")
}
// Allow at most one ChangeDatabaseConfig with release.
if releaseCount > 1 {
return nil, errors.Errorf("plan contains multiple change database configs with release, but only one is allowed")
}
// Allow at most one instance.
if len(instanceTargets) > 1 {
return nil, errors.Errorf("plan contains targets on multiple instances, but only one instance is allowed")
}
// Allow at most one database group.
if len(databaseGroups) > 1 {
return nil, errors.Errorf("plan contains multiple database groups, but only one is allowed")
}
// Don't allow mixing database group and databases.
if len(databaseGroups) > 0 && len(databaseNames) > 0 {
return nil, errors.Errorf("plan contains both database group and databases, but only one is allowed")
}
// Validate resources existence.
if len(instanceTargets) == 1 {
instance, err := getInstanceMessage(ctx, s, instanceTargets[0])
if err != nil {
return nil, err
}
if instance.Deleted {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("instance %q has been deleted", instanceTargets[0]))
}
}
if len(databaseGroups) == 1 {
name := databaseGroups[0]
groupProjectID, _, err := common.GetProjectIDDatabaseGroupID(name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid database group name %q", name))
}
if groupProjectID != projectID {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("database group %q (project %q) does not belong to plan project %q", name, groupProjectID, projectID))
}
dg, err := getDatabaseGroupByName(ctx, s, name, v1pb.DatabaseGroupView_DATABASE_GROUP_VIEW_FULL)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get database group %q: %v", name, err))
}
if dg == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database group %q not found", name))
}
databaseGroup = dg
}
for _, name := range databaseNames {
targetProjectID, instanceID, dbName, err := common.GetDatabaseResourceName(name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid database name %q", name))
}
if targetProjectID != nil && *targetProjectID != projectID {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("database %q (project %q) does not belong to plan project %q", name, *targetProjectID, projectID))
}
db, err := s.GetDatabase(ctx, &store.FindDatabaseMessage{
Workspace: common.GetWorkspaceIDFromContext(ctx),
InstanceID: &instanceID,
DatabaseName: &dbName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get database %q: %v", name, err))
}
if db == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", name))
}
instanceName := common.FormatInstance(instanceID)
if targetProjectID != nil {
instanceName = common.FormatProjectInstance(*targetProjectID, instanceID)
}
instance, err := getInstanceMessage(ctx, s, instanceName)
if err != nil {
return nil, err
}
if instance.Deleted {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("instance %q has been deleted", instanceName))
}
if db.ProjectID != projectID {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("database %q (project %q) does not belong to plan project %q", name, db.ProjectID, projectID))
}
}
// Validate release existence.
if releaseString != "" {
releaseProjectID, releaseID, err := common.GetProjectReleaseID(releaseString)
if err != nil {
return nil, errors.Errorf("invalid release name %q", releaseString)
}
if releaseProjectID != projectID {
return nil, errors.Errorf("release %q (project %q) does not belong to plan project %q", releaseString, releaseProjectID, projectID)
}
release, err := s.GetRelease(ctx, &store.FindReleaseMessage{
ProjectID: &releaseProjectID,
ReleaseID: &releaseID,
})
if err != nil {
return nil, errors.Errorf("failed to get release %s: %v", releaseID, err)
}
if release == nil {
return nil, errors.Errorf("release %s not found", releaseID)
}
// The release's files were validated against this project when the
// release was created (releases are immutable — UpdateRelease is
// Unimplemented), and refs are deleted only by project purge, which
// deletes the release too. No per-use recheck of its files.
}
// Validate sheets existence.
if len(sheetSha256s) > 0 {
missing, err := s.MissingSheetsForProject(ctx, projectID, sheetSha256s...)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to check sheets: %v", err))
}
if len(missing) > 0 {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("sheet %q not found", common.FormatSheet(projectID, missing[0])))
}
}
return databaseGroup, nil
}
func storePlanConfigHasRelease(plan *storepb.PlanConfig) bool {
for _, spec := range plan.GetSpecs() {
if c, ok := spec.Config.(*storepb.PlanConfig_Spec_ChangeDatabaseConfig); ok {
if c.ChangeDatabaseConfig.Release != "" {
return true
}
}
}
return false
}
func storePlanConfigHasCreateDatabase(plan *storepb.PlanConfig) bool {
for _, spec := range plan.GetSpecs() {
if _, ok := spec.Config.(*storepb.PlanConfig_Spec_CreateDatabaseConfig); ok {
return true
}
}
return false
}
// Converters section - ordered with callers before callees.
// getPlanCheckRunFromPlan returns the plan check run for a plan.
func getPlanCheckRunFromPlan(ctx context.Context, s *store.Store, project *store.ProjectMessage, plan *store.PlanMessage, databaseGroup *v1pb.DatabaseGroup) (*store.PlanCheckRunMessage, error) {
targets, err := plancheck.DeriveCheckTargets(ctx, s, project, plan, databaseGroup)
if err != nil {
return nil, err
}
if len(targets) == 0 {
return nil, nil
}
return &store.PlanCheckRunMessage{
ProjectID: plan.ProjectID,
PlanUID: plan.UID,
Status: store.PlanCheckRunStatusAvailable,
Result: &storepb.PlanCheckRunResult{
ApprovalInputVersion: plan.Config.GetApprovalInputVersion(),
},
}, nil
}
func convertToPlans(ctx context.Context, s *store.Store, plans []*store.PlanMessage) ([]*v1pb.Plan, error) {
if len(plans) == 0 {
return nil, nil
}
workspaceID := common.GetWorkspaceIDFromContext(ctx)
planUIDs := make([]int64, 0, len(plans))
rolloutPlanUIDs := make([]int64, 0, len(plans))
projectIDSet := make(map[string]struct{}, len(plans))
for _, plan := range plans {
planUIDs = append(planUIDs, plan.UID)
if plan.Config != nil && plan.Config.HasRollout {
rolloutPlanUIDs = append(rolloutPlanUIDs, plan.UID)
}
projectIDSet[plan.ProjectID] = struct{}{}
}
projectIDs := make([]string, 0, len(projectIDSet))
for projectID := range projectIDSet {
projectIDs = append(projectIDs, projectID)
}
issues, err := s.ListIssues(ctx, &store.FindIssueMessage{
Workspace: workspaceID,
ProjectIDs: projectIDs,
PlanUIDs: &planUIDs,
})
if err != nil {
return nil, errors.Wrap(err, "failed to batch list issues")
}
planCheckRuns, err := s.ListPlanCheckRuns(ctx, &store.FindPlanCheckRunMessage{
ProjectIDs: &projectIDs,
PlanUIDs: &planUIDs,
})
if err != nil {
return nil, errors.Wrap(err, "failed to batch list plan check runs")
}
var taskStatusCounts []*store.TaskStatusCount
environmentOrderMap := map[string]int{}
if len(rolloutPlanUIDs) > 0 {
environmentSetting, err := s.GetEnvironment(ctx, workspaceID)
if err != nil {
return nil, errors.Wrap(err, "failed to get environments")
}
environmentOrderMap = common.EnvironmentOrderMap(environmentSetting.GetEnvironments())
taskStatusCounts, err = s.ListTaskStatusCountByPlanIDs(ctx, projectIDs, rolloutPlanUIDs)
if err != nil {
return nil, errors.Wrap(err, "failed to batch list task status counts")
}
}
return buildV1Plans(plans, issues, planCheckRuns, taskStatusCounts, environmentOrderMap), nil
}
// buildV1Plans joins the batch reads onto their plans. Every relation is keyed
// by (project, plan UID) rather than by UID alone: plan UIDs are allocated per
// project, so the same number names a different plan in every project.
func buildV1Plans(plans []*store.PlanMessage, issues []*store.IssueMessage, planCheckRuns []*store.PlanCheckRunMessage, taskStatusCounts []*store.TaskStatusCount, environmentOrderMap map[string]int) []*v1pb.Plan {
type planKey struct {
projectID string
planUID int64
}
issueByPlanKey := make(map[planKey]*store.IssueMessage, len(issues))
for _, issue := range issues {
if issue.PlanUID != nil {
issueByPlanKey[planKey{projectID: issue.ProjectID, planUID: *issue.PlanUID}] = issue
}
}
planCheckRunByPlanKey := make(map[planKey]*store.PlanCheckRunMessage, len(planCheckRuns))
for _, run := range planCheckRuns {
planCheckRunByPlanKey[planKey{projectID: run.ProjectID, planUID: run.PlanUID}] = run
}
taskStatusCountByPlanKey := make(map[planKey][]*store.TaskStatusCount)
for _, count := range taskStatusCounts {
key := planKey{projectID: count.ProjectID, planUID: count.PlanID}
taskStatusCountByPlanKey[key] = append(taskStatusCountByPlanKey[key], count)
}
v1Plans := make([]*v1pb.Plan, len(plans))
for i, plan := range plans {
key := planKey{projectID: plan.ProjectID, planUID: plan.UID}
v1Plan := buildV1PlanFields(plan)
if issue := issueByPlanKey[key]; issue != nil {
v1Plan.Issue = common.FormatIssue(issue.ProjectID, issue.UID)
v1Plan.IssueStatus = convertToIssueStatus(issue.Status)
if !issue.Payload.GetDraft() {
v1Plan.ApprovalStatus = store.ComputeApprovalStatus(issue.Payload.GetApproval())
}
}
if planCheckRun := planCheckRunByPlanKey[key]; planCheckRun != nil {
v1Plan.PlanCheckRunStatusCount[string(planCheckRun.Status)]++
for _, result := range planCheckRun.Result.Results {
v1Plan.PlanCheckRunStatusCount[storepb.Advice_Status_name[int32(result.Status)]]++
}
}
if counts := taskStatusCountByPlanKey[key]; len(counts) > 0 {
v1Plan.RolloutStageSummaries = buildRolloutStageSummaries(plan.ProjectID, plan.UID, counts, environmentOrderMap)
}
v1Plans[i] = v1Plan
}
return v1Plans
}
func convertToPlan(ctx context.Context, s *store.Store, plan *store.PlanMessage) (*v1pb.Plan, error) {
plans, err := convertToPlans(ctx, s, []*store.PlanMessage{plan})
if err != nil {
return nil, err
}
return plans[0], nil
}
func buildV1PlanFields(plan *store.PlanMessage) *v1pb.Plan {
var specs []*v1pb.Plan_Spec
if plan.Config != nil {
specs = convertToPlanSpecs(plan.ProjectID, plan.Config.Specs)
}
p := &v1pb.Plan{
Name: common.FormatPlan(plan.ProjectID, plan.UID),
Title: plan.Name,
Description: plan.Description,
Creator: common.FormatUserEmail(plan.Creator),
LastPlanEditor: common.FormatUserEmail(effectivePlanEditor(plan)),
Specs: specs,
CreateTime: timestamppb.New(plan.CreatedAt),
UpdateTime: timestamppb.New(plan.UpdatedAt),
State: convertDeletedToState(plan.Deleted),
PlanCheckRunStatusCount: map[string]int32{},
}
if plan.Config != nil {
p.HasRollout = plan.Config.HasRollout
}
return p
}
func effectivePlanEditor(plan *store.PlanMessage) string {
if plan.LastPlanEditor != nil {
return *plan.LastPlanEditor
}
return plan.Creator
}
func buildRolloutStageSummaries(projectID string, planUID int64, counts []*store.TaskStatusCount, environmentOrderMap map[string]int) []*v1pb.Plan_RolloutStageSummary {
summariesByEnvironment := make(map[string]map[v1pb.Task_Status]int32)
for _, count := range counts {
if _, exists := environmentOrderMap[count.Environment]; !exists {
continue
}
status, ok := convertTaskRunStatusStringToAPITaskStatus(count.Status)
if !ok {
continue
}
if _, exists := summariesByEnvironment[count.Environment]; !exists {
summariesByEnvironment[count.Environment] = make(map[v1pb.Task_Status]int32)
}
summariesByEnvironment[count.Environment][status] += count.Count
}
environments := make([]string, 0, len(summariesByEnvironment))
for environment := range summariesByEnvironment {
environments = append(environments, environment)
}
slices.SortFunc(environments, func(a, b string) int {
return environmentOrderMap[a] - environmentOrderMap[b]
})
summaries := make([]*v1pb.Plan_RolloutStageSummary, 0, len(environments))
for _, environment := range environments {
stageID := common.FormatStageID(environment)
statusCounts := make([]*v1pb.Plan_TaskStatusCount, 0, len(summariesByEnvironment[environment]))
for _, status := range []v1pb.Task_Status{
v1pb.Task_NOT_STARTED,
v1pb.Task_PENDING,
v1pb.Task_RUNNING,
v1pb.Task_DONE,
v1pb.Task_FAILED,
v1pb.Task_CANCELED,
v1pb.Task_SKIPPED,
} {
if count, exists := summariesByEnvironment[environment][status]; exists {
statusCounts = append(statusCounts, &v1pb.Plan_TaskStatusCount{
Status: status,
Count: count,
})
}
}
summaries = append(summaries, &v1pb.Plan_RolloutStageSummary{
Stage: common.FormatStage(projectID, planUID, stageID),
TaskStatusCounts: statusCounts,
})
}
return summaries
}
func convertTaskRunStatusStringToAPITaskStatus(status string) (v1pb.Task_Status, bool) {
switch status {
case storepb.TaskRun_NOT_STARTED.String():
return v1pb.Task_NOT_STARTED, true
case storepb.TaskRun_PENDING.String():
return v1pb.Task_PENDING, true
case storepb.TaskRun_RUNNING.String():
return v1pb.Task_RUNNING, true
case storepb.TaskRun_DONE.String():
return v1pb.Task_DONE, true
case storepb.TaskRun_FAILED.String():
return v1pb.Task_FAILED, true
case storepb.TaskRun_CANCELED.String():
return v1pb.Task_CANCELED, true
case storepb.TaskRun_SKIPPED.String():
return v1pb.Task_SKIPPED, true
default:
return v1pb.Task_STATUS_UNSPECIFIED, false
}
}
func convertPlan(plan *v1pb.Plan) *storepb.PlanConfig {
if plan == nil {
return nil
}
// At this point, plan.Specs should always be populated
// (either originally or converted from steps at API entry point)
return &storepb.PlanConfig{
Specs: convertPlanSpecs(plan.Specs),
}
}
func convertToPlanCheckRun(projectID string, planUID int64, run *store.PlanCheckRunMessage) *v1pb.PlanCheckRun {
return &v1pb.PlanCheckRun{
Name: common.FormatPlanCheckRun(projectID, planUID),
Status: convertToPlanCheckRunStatus(run.Status),
Results: convertToPlanCheckRunResults(run.Result.GetResults()),
Error: run.Result.Error,
CreateTime: timestamppb.New(run.CreatedAt),
}
}
func convertToPlanSpecs(projectID string, specs []*storepb.PlanConfig_Spec) []*v1pb.Plan_Spec {
v1Specs := make([]*v1pb.Plan_Spec, len(specs))
for i := range specs {
v1Specs[i] = convertToPlanSpec(projectID, specs[i])
}
return v1Specs
}
func convertToPlanSpec(projectID string, spec *storepb.PlanConfig_Spec) *v1pb.Plan_Spec {
v1Spec := &v1pb.Plan_Spec{
Id: spec.Id,
}
switch v := spec.Config.(type) {
case *storepb.PlanConfig_Spec_CreateDatabaseConfig:
v1Spec.Config = convertToPlanSpecCreateDatabaseConfig(v)
case *storepb.PlanConfig_Spec_ChangeDatabaseConfig:
v1Spec.Config = convertToPlanSpecChangeDatabaseConfig(projectID, v)
default:
}
return v1Spec
}
func convertToPlanSpecCreateDatabaseConfig(config *storepb.PlanConfig_Spec_CreateDatabaseConfig) *v1pb.Plan_Spec_CreateDatabaseConfig {
c := config.CreateDatabaseConfig
return &v1pb.Plan_Spec_CreateDatabaseConfig{
CreateDatabaseConfig: &v1pb.Plan_CreateDatabaseConfig{
Target: c.Target,
Database: c.Database,
Table: c.Table,
CharacterSet: c.CharacterSet,
Collation: c.Collation,
Cluster: c.Cluster,
Owner: c.Owner,
Environment: c.Environment,
},
}
}
func convertToPlanSpecChangeDatabaseConfig(projectID string, config *storepb.PlanConfig_Spec_ChangeDatabaseConfig) *v1pb.Plan_Spec_ChangeDatabaseConfig {
c := config.ChangeDatabaseConfig
// Only format sheet if SheetSha256 is not empty (for non-release tasks)
var sheet string
if c.SheetSha256 != "" {
sheet = common.FormatSheet(projectID, c.SheetSha256)
}
return &v1pb.Plan_Spec_ChangeDatabaseConfig{
ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
Targets: c.Targets,
Sheet: sheet,
Release: c.Release,
EnablePriorBackup: c.EnablePriorBackup,
},
}
}
func convertPlanSpecs(specs []*v1pb.Plan_Spec) []*storepb.PlanConfig_Spec {
storeSpecs := make([]*storepb.PlanConfig_Spec, len(specs))
for i := range specs {
storeSpecs[i] = convertPlanSpec(specs[i])
}
return storeSpecs
}
func convertPlanSpec(spec *v1pb.Plan_Spec) *storepb.PlanConfig_Spec {
storeSpec := &storepb.PlanConfig_Spec{
Id: spec.Id,
}
switch v := spec.Config.(type) {
case *v1pb.Plan_Spec_CreateDatabaseConfig:
storeSpec.Config = convertPlanSpecCreateDatabaseConfig(v)
case *v1pb.Plan_Spec_ChangeDatabaseConfig:
storeSpec.Config = convertPlanSpecChangeDatabaseConfig(v)
default:
}
return storeSpec
}
func convertPlanSpecCreateDatabaseConfig(config *v1pb.Plan_Spec_CreateDatabaseConfig) *storepb.PlanConfig_Spec_CreateDatabaseConfig {
c := config.CreateDatabaseConfig
return &storepb.PlanConfig_Spec_CreateDatabaseConfig{
CreateDatabaseConfig: convertPlanConfigCreateDatabaseConfig(c),
}
}
func convertPlanConfigCreateDatabaseConfig(c *v1pb.Plan_CreateDatabaseConfig) *storepb.PlanConfig_CreateDatabaseConfig {
return &storepb.PlanConfig_CreateDatabaseConfig{
Target: c.Target,
Database: c.Database,
Table: c.Table,
CharacterSet: c.CharacterSet,
Collation: c.Collation,
Cluster: c.Cluster,
Owner: c.Owner,
Environment: c.Environment,
}
}
func convertPlanSpecChangeDatabaseConfig(config *v1pb.Plan_Spec_ChangeDatabaseConfig) *storepb.PlanConfig_Spec_ChangeDatabaseConfig {
c := config.ChangeDatabaseConfig
// Sheet can be empty when using Release-based workflow (SQL comes from release files).
// Plans can use either Sheet-based or Release-based approach, but not both.
var sheetSha256 string
if c.Sheet != "" {
_, sha256, err := common.GetProjectResourceIDSheetSha256(c.Sheet)
if err != nil {
return nil
}
sheetSha256 = sha256
}
return &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
Targets: c.Targets,
SheetSha256: sheetSha256,
Release: c.Release,
EnablePriorBackup: c.EnablePriorBackup,
},
}
}
func convertToPlanCheckRunStatus(status store.PlanCheckRunStatus) v1pb.PlanCheckRun_Status {
switch status {
case store.PlanCheckRunStatusCanceled:
return v1pb.PlanCheckRun_CANCELED
case store.PlanCheckRunStatusDone:
return v1pb.PlanCheckRun_DONE
case store.PlanCheckRunStatusFailed:
return v1pb.PlanCheckRun_FAILED
case store.PlanCheckRunStatusRunning:
return v1pb.PlanCheckRun_RUNNING
default:
return v1pb.PlanCheckRun_STATUS_UNSPECIFIED
}
}
func convertToPlanCheckRunResults(results []*storepb.PlanCheckRunResult_Result) []*v1pb.PlanCheckRun_Result {
var resultsV1 []*v1pb.PlanCheckRun_Result
for _, result := range results {
resultsV1 = append(resultsV1, convertToPlanCheckRunResult(result))
}
return resultsV1
}
func convertToPlanCheckRunResult(result *storepb.PlanCheckRunResult_Result) *v1pb.PlanCheckRun_Result {
resultV1 := &v1pb.PlanCheckRun_Result{
Status: convertToPlanCheckRunResultStatus(result.Status),
Title: result.Title,
Content: result.Content,
Code: result.Code,
Target: result.Target,
Type: convertToV1ResultType(result.Type),
Report: nil,
}
switch report := result.Report.(type) {
case *storepb.PlanCheckRunResult_Result_SqlSummaryReport_:
resultV1.Report = &v1pb.PlanCheckRun_Result_SqlSummaryReport_{
SqlSummaryReport: &v1pb.PlanCheckRun_Result_SqlSummaryReport{
StatementTypes: convertStatementTypesToV1(report.SqlSummaryReport.StatementTypes),
AffectedRows: report.SqlSummaryReport.AffectedRows,
},
}
case *storepb.PlanCheckRunResult_Result_SqlReviewReport_:
resultV1.Report = &v1pb.PlanCheckRun_Result_SqlReviewReport_{
SqlReviewReport: &v1pb.PlanCheckRun_Result_SqlReviewReport{
StartPosition: convertToPosition(report.SqlReviewReport.StartPosition),
EndPosition: convertToPosition(report.SqlReviewReport.EndPosition),
},
}
default:
}
return resultV1
}
func convertToV1ResultType(t storepb.PlanCheckType) v1pb.PlanCheckRun_Result_Type {
switch t {
case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_ADVISE:
return v1pb.PlanCheckRun_Result_STATEMENT_ADVISE
case storepb.PlanCheckType_PLAN_CHECK_TYPE_STATEMENT_SUMMARY_REPORT:
return v1pb.PlanCheckRun_Result_STATEMENT_SUMMARY_REPORT
case storepb.PlanCheckType_PLAN_CHECK_TYPE_GHOST_SYNC:
return v1pb.PlanCheckRun_Result_GHOST_SYNC
default:
return v1pb.PlanCheckRun_Result_TYPE_UNSPECIFIED
}
}
func convertStatementTypesToV1(storeTypes []storepb.StatementType) []v1pb.StatementType {
result := make([]v1pb.StatementType, len(storeTypes))
for i, t := range storeTypes {
result[i] = v1pb.StatementType(t)
}
return result
}
func convertToPlanCheckRunResultStatus(status storepb.Advice_Status) v1pb.Advice_Level {
switch status {
case storepb.Advice_STATUS_UNSPECIFIED:
return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED
case storepb.Advice_SUCCESS:
return v1pb.Advice_SUCCESS
case storepb.Advice_WARNING:
return v1pb.Advice_WARNING
case storepb.Advice_ERROR:
return v1pb.Advice_ERROR
default:
return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED
}
}