Skip to content

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

refactor: add project-level filtering (#17902)

boojackf6b3bb47f332
diff --git a/backend/api/v1/issue_service.go b/backend/api/v1/issue_service.go
index 6df829ce87..7390331433 100644
--- a/backend/api/v1/issue_service.go
+++ b/backend/api/v1/issue_service.go
@@ -425,12 +425,12 @@ func (s *IssueService) createIssueDatabaseChange(ctx context.Context, request *v
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
- plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &planID})
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &planID, ProjectID: &projectID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan, error: %v", err))
}
if plan == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan not found for id: %d", planID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %d not found in project %s", planID, projectID))
}
planUID = &plan.UID
var rolloutUID *int
@@ -439,12 +439,15 @@ func (s *IssueService) createIssueDatabaseChange(ctx context.Context, request *v
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
- pipeline, err := s.store.GetPipelineV2ByID(ctx, rolloutID)
+ pipeline, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
}
if pipeline == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout not found for id: %d", rolloutID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))
}
rolloutUID = &pipeline.ID
}
@@ -616,12 +619,12 @@ func (s *IssueService) createIssueDatabaseDataExport(ctx context.Context, reques
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
- plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &planID})
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &planID, ProjectID: &projectID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan, error: %v", err))
}
if plan == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan not found for id: %d", planID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %d not found in project %s", planID, projectID))
}
planUID = &plan.UID
var rolloutUID *int
@@ -630,12 +633,15 @@ func (s *IssueService) createIssueDatabaseDataExport(ctx context.Context, reques
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
- pipeline, err := s.store.GetPipelineV2ByID(ctx, rolloutID)
+ pipeline, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
}
if pipeline == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout not found for id: %d", rolloutID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))
}
rolloutUID = &pipeline.ID
}
@@ -1375,14 +1381,20 @@ func (s *IssueService) ListIssueComments(ctx context.Context, req *connect.Reque
if req.Msg.PageSize < 0 {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("page size must be non-negative: %d", req.Msg.PageSize))
}
- _, issueUID, err := common.GetProjectIDIssueUID(req.Msg.Parent)
+ projectID, issueUID, err := common.GetProjectIDIssueUID(req.Msg.Parent)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
- issue, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{UID: &issueUID})
+ issue, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{
+ UID: &issueUID,
+ ProjectID: &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,
@@ -1515,16 +1527,19 @@ func (s *IssueService) UpdateIssueComment(ctx context.Context, req *connect.Requ
}
func (s *IssueService) getIssueMessage(ctx context.Context, name string) (*store.IssueMessage, error) {
- issueID, err := common.GetIssueID(name)
+ projectID, issueUID, err := common.GetProjectIDIssueUID(name)
if err != nil {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
+ return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
- issue, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{UID: &issueID})
+ issue, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{
+ UID: &issueUID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get issue, error: %v", err))
}
if issue == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("issue %d not found", issueID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("issue %d not found in project %s", issueUID, projectID))
}
return issue, nil
}
diff --git a/backend/api/v1/plan_service.go b/backend/api/v1/plan_service.go
index 16ee9aa031..b26540248f 100644
--- a/backend/api/v1/plan_service.go
+++ b/backend/api/v1/plan_service.go
@@ -61,21 +61,15 @@ func (s *PlanService) GetPlan(ctx context.Context, request *connect.Request[v1pb
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
- project, err := s.store.GetProjectV2(ctx, &store.FindProjectMessage{
- ResourceID: &projectID,
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{
+ UID: &planID,
+ ProjectID: &projectID,
})
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get project, error: %v", err))
- }
- 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{UID: &planID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan, error: %v", err))
}
if plan == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan not found for id: %d", planID))
+ 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 {
@@ -607,7 +601,7 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[v
}
oldSheetName = config.ChangeDatabaseConfig.Sheet
}
- _, sheetUID, err := common.GetProjectResourceIDSheetUID(oldSheetName)
+ sheetProjectID, sheetUID, err := common.GetProjectResourceIDSheetUID(oldSheetName)
if err != nil {
return connect.NewError(connect.CodeInternal, errors.Errorf("failed to get sheet id from %q, error: %v", oldSheetName, err))
}
@@ -616,13 +610,14 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[v
}
sheet, err := s.store.GetSheet(ctx, &store.FindSheetMessage{
- UID: &sheetUID,
+ UID: &sheetUID,
+ ProjectID: &sheetProjectID,
})
if err != nil {
return connect.NewError(connect.CodeInternal, errors.Errorf("failed to get sheet %q: %v", oldSheetName, err))
}
if sheet == nil {
- return connect.NewError(connect.CodeNotFound, errors.Errorf("sheet %q not found", oldSheetName))
+ return connect.NewError(connect.CodeNotFound, errors.Errorf("sheet %d not found in project %s", sheetUID, sheetProjectID))
}
doUpdate = true
taskPatch.SheetID = &sheet.UID
@@ -761,7 +756,10 @@ func (s *PlanService) UpdatePlan(ctx context.Context, request *connect.Request[v
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to update plan %q: %v", req.Plan.Name, err))
}
- updatedPlan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &oldPlan.UID})
+ updatedPlan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{
+ UID: &oldPlan.UID,
+ ProjectID: &oldPlan.ProjectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get updated plan %q: %v", req.Plan.Name, err))
}
@@ -993,7 +991,10 @@ func (s *PlanService) RunPlanChecks(ctx context.Context, request *connect.Reques
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{UID: &planID})
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{
+ UID: &planID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan, error: %v", err))
}
diff --git a/backend/api/v1/plan_service_converter.go b/backend/api/v1/plan_service_converter.go
index 548e89a211..fbf89247e3 100644
--- a/backend/api/v1/plan_service_converter.go
+++ b/backend/api/v1/plan_service_converter.go
@@ -324,12 +324,12 @@ func convertToPlanCheckRun(ctx context.Context, s *store.Store, projectID string
}
if sheetUID := int(run.Config.GetSheetUid()); sheetUID != 0 {
- sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID})
+ sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID, ProjectID: &projectID})
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheet")
}
if sheet == nil {
- return nil, errors.Errorf("sheet not found for uid %d", sheetUID)
+ return nil, errors.Errorf("sheet %d not found in project %s", sheetUID, projectID)
}
converted.Sheet = common.FormatSheet(projectID, sheet.UID)
}
diff --git a/backend/api/v1/plan_service_plan_check.go b/backend/api/v1/plan_service_plan_check.go
index b0e5af3d96..b30f8c8924 100644
--- a/backend/api/v1/plan_service_plan_check.go
+++ b/backend/api/v1/plan_service_plan_check.go
@@ -177,12 +177,15 @@ func getPlanCheckRunsFromChangeDatabaseConfigForDatabase(ctx context.Context, s
if instance == nil {
return nil, errors.Errorf("instance %q not found", database.InstanceID)
}
- sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID})
+ sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{
+ UID: &sheetUID,
+ ProjectID: &plan.ProjectID,
+ })
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheet %d", sheetUID)
}
if sheet == nil {
- return nil, errors.Errorf("sheet %d not found", sheetUID)
+ return nil, errors.Errorf("sheet %d not found in project %s", sheetUID, plan.ProjectID)
}
var planCheckRuns []*store.PlanCheckRunMessage
diff --git a/backend/api/v1/release_service.go b/backend/api/v1/release_service.go
index 6735b4bd46..ea0d822689 100644
--- a/backend/api/v1/release_service.go
+++ b/backend/api/v1/release_service.go
@@ -69,7 +69,7 @@ func (s *ReleaseService) CreateRelease(ctx context.Context, req *connect.Request
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))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", projectID))
}
sanitizedFiles, err := validateAndSanitizeReleaseFiles(ctx, s.store, req.Msg.Release.Files, true)
@@ -137,16 +137,19 @@ func (s *ReleaseService) CreateRelease(ctx context.Context, req *connect.Request
}
func (s *ReleaseService) GetRelease(ctx context.Context, req *connect.Request[v1pb.GetReleaseRequest]) (*connect.Response[v1pb.Release], error) {
- _, releaseUID, err := common.GetProjectReleaseUID(req.Msg.Name)
+ projectID, releaseUID, err := common.GetProjectReleaseUID(req.Msg.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to get release uid"))
}
- releaseMessage, err := s.store.GetRelease(ctx, releaseUID)
+ releaseMessage, err := s.store.GetReleaseV2(ctx, &store.FindReleaseMessage{
+ ProjectID: &projectID,
+ UID: &releaseUID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get release"))
}
if releaseMessage == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("release %v not found", releaseUID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("release %d not found in project %s", releaseUID, projectID))
}
release, err := convertToRelease(ctx, s.store, releaseMessage)
if err != nil {
@@ -169,7 +172,7 @@ func (s *ReleaseService) ListReleases(ctx context.Context, req *connect.Request[
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))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", projectID))
}
offset, err := parseLimitAndOffset(&pageSize{
@@ -227,7 +230,7 @@ func (s *ReleaseService) SearchReleases(ctx context.Context, req *connect.Reques
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))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", projectID))
}
offset, err := parseLimitAndOffset(&pageSize{
@@ -289,7 +292,11 @@ func (s *ReleaseService) UpdateRelease(ctx context.Context, req *connect.Request
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("user not found"))
}
- release, err := s.store.GetRelease(ctx, releaseUID)
+ // Use GetReleaseV2 with FindReleaseMessage for database-level filtering
+ release, err := s.store.GetReleaseV2(ctx, &store.FindReleaseMessage{
+ ProjectID: &projectID,
+ UID: &releaseUID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get release"))
}
@@ -300,7 +307,7 @@ func (s *ReleaseService) UpdateRelease(ctx context.Context, req *connect.Request
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))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %s not found", projectID))
}
ok, err := s.iamManager.CheckPermission(ctx, iam.PermissionReleasesCreate, user, project.ResourceID)
if err != nil {
@@ -314,8 +321,9 @@ func (s *ReleaseService) UpdateRelease(ctx context.Context, req *connect.Request
Release: req.Msg.Release,
}))
}
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("release %v not found", releaseUID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("release %d not found in project %s", releaseUID, projectID))
}
+
if release.Deleted {
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.Errorf("release %d is deleted", releaseUID))
}
@@ -343,10 +351,21 @@ func (s *ReleaseService) UpdateRelease(ctx context.Context, req *connect.Request
}
func (s *ReleaseService) DeleteRelease(ctx context.Context, req *connect.Request[v1pb.DeleteReleaseRequest]) (*connect.Response[emptypb.Empty], error) {
- _, releaseUID, err := common.GetProjectReleaseUID(req.Msg.Name)
+ projectID, releaseUID, err := common.GetProjectReleaseUID(req.Msg.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to get release uid"))
}
+ release, err := s.store.GetReleaseV2(ctx, &store.FindReleaseMessage{
+ ProjectID: &projectID,
+ UID: &releaseUID,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get release"))
+ }
+ if release == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("release %d not found in project %s", releaseUID, projectID))
+ }
+
if _, err := s.store.UpdateRelease(ctx, &store.UpdateReleaseMessage{
UID: releaseUID,
Deleted: &deletePatch,
@@ -357,10 +376,22 @@ func (s *ReleaseService) DeleteRelease(ctx context.Context, req *connect.Request
}
func (s *ReleaseService) UndeleteRelease(ctx context.Context, req *connect.Request[v1pb.UndeleteReleaseRequest]) (*connect.Response[v1pb.Release], error) {
- _, releaseUID, err := common.GetProjectReleaseUID(req.Msg.Name)
+ projectID, releaseUID, err := common.GetProjectReleaseUID(req.Msg.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to get release uid"))
}
+ release, err := s.store.GetReleaseV2(ctx, &store.FindReleaseMessage{
+ ProjectID: &projectID,
+ UID: &releaseUID,
+ ShowDeleted: true,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get release"))
+ }
+ if release == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("release %d not found in project %s", releaseUID, projectID))
+ }
+
releaseMessage, err := s.store.UpdateRelease(ctx, &store.UpdateReleaseMessage{
UID: releaseUID,
Deleted: &undeletePatch,
@@ -368,11 +399,11 @@ func (s *ReleaseService) UndeleteRelease(ctx context.Context, req *connect.Reque
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to undelete release"))
}
- release, err := convertToRelease(ctx, s.store, releaseMessage)
+ releaseConverted, err := convertToRelease(ctx, s.store, releaseMessage)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert release"))
}
- return connect.NewResponse(release), nil
+ return connect.NewResponse(releaseConverted), nil
}
func convertToReleases(ctx context.Context, s *store.Store, releases []*store.ReleaseMessage) ([]*v1pb.Release, error) {
@@ -407,7 +438,7 @@ func convertToRelease(ctx context.Context, s *store.Store, release *store.Releas
return nil, errors.Wrapf(err, "failed to find project")
}
if project == nil {
- return nil, errors.Wrapf(err, "project %s not found", release.ProjectID)
+ return nil, errors.Errorf("project %s not found", release.ProjectID)
}
r.Name = common.FormatReleaseName(project.ResourceID, release.UID)
@@ -426,16 +457,16 @@ func convertToReleaseFiles(ctx context.Context, s *store.Store, files []*storepb
}
var v1Files []*v1pb.Release_File
for _, f := range files {
- _, sheetUID, err := common.GetProjectResourceIDSheetUID(f.Sheet)
+ projectID, sheetUID, err := common.GetProjectResourceIDSheetUID(f.Sheet)
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheetUID from %q", f.Sheet)
}
- sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID})
+ sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID, ProjectID: &projectID})
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheet %q", f.Sheet)
}
if sheet == nil {
- return nil, errors.Errorf("sheet %q not found", f.Sheet)
+ return nil, errors.Errorf("sheet %d not found in project %s", sheetUID, projectID)
}
v1Files = append(v1Files, &v1pb.Release_File{
Id: f.Id,
@@ -468,19 +499,20 @@ func convertReleaseFiles(ctx context.Context, s *store.Store, files []*v1pb.Rele
}
var rFiles []*storepb.ReleasePayload_File
for _, f := range files {
- _, sheetUID, err := common.GetProjectResourceIDSheetUID(f.Sheet)
+ projectID, sheetUID, err := common.GetProjectResourceIDSheetUID(f.Sheet)
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheetUID from %q", f.Sheet)
}
sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{
- UID: &sheetUID,
- LoadFull: false,
+ UID: &sheetUID,
+ ProjectID: &projectID,
+ LoadFull: false,
})
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheet %q", f.Sheet)
}
if sheet == nil {
- return nil, errors.Errorf("sheet %q not found", f.Sheet)
+ return nil, errors.Errorf("sheet %d not found in project %s", sheetUID, projectID)
}
rFiles = append(rFiles, &storepb.ReleasePayload_File{
@@ -534,19 +566,20 @@ func validateAndSanitizeReleaseFiles(ctx context.Context, s *store.Store, files
// If sheet is provided but statement is not, populate statement from sheet
case f.Sheet != "":
- _, sheetUID, err := common.GetProjectResourceIDSheetUID(f.Sheet)
+ projectID, sheetUID, err := common.GetProjectResourceIDSheetUID(f.Sheet)
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheet UID from %q", f.Sheet)
}
sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{
- UID: &sheetUID,
- LoadFull: true,
+ UID: &sheetUID,
+ ProjectID: &projectID,
+ LoadFull: true,
})
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheet %q", f.Sheet)
}
if sheet == nil {
- return nil, errors.Errorf("sheet %q not found", f.Sheet)
+ return nil, errors.Errorf("sheet %d not found in project %s", sheetUID, projectID)
}
f.Statement = []byte(sheet.Statement)
f.SheetSha256 = sheet.GetSha256Hex()
diff --git a/backend/api/v1/revision_service.go b/backend/api/v1/revision_service.go
index 1ab896871e..bd641fa993 100644
--- a/backend/api/v1/revision_service.go
+++ b/backend/api/v1/revision_service.go
@@ -127,16 +127,16 @@ func (s *RevisionService) CreateRevision(
if database == nil || database.Deleted {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %v not found", request.Parent))
}
- _, sheetUID, err := common.GetProjectResourceIDSheetUID(request.Revision.Sheet)
+ sheetProjectID, sheetUID, err := common.GetProjectResourceIDSheetUID(request.Revision.Sheet)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to get sheet from %v", request.Revision.Sheet))
}
- sheet, err := s.store.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID})
+ sheet, err := s.store.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID, ProjectID: &sheetProjectID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get sheet"))
}
if sheet == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("sheet %q not found", request.Revision.Sheet))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("sheet %d not found in project %s", sheetUID, sheetProjectID))
}
if request.Revision.TaskRun != "" {
@@ -181,7 +181,7 @@ func (s *RevisionService) CreateRevision(
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to get release and file from %q", request.Revision.File))
}
- release, err := s.store.GetRelease(ctx, releaseUID)
+ release, err := s.store.GetReleaseByUID(ctx, releaseUID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get release"))
}
@@ -281,16 +281,16 @@ func convertToRevisions(ctx context.Context, s *store.Store, parent string, revi
}
func convertToRevision(ctx context.Context, s *store.Store, parent string, revision *store.RevisionMessage) (*v1pb.Revision, error) {
- _, sheetUID, err := common.GetProjectResourceIDSheetUID(revision.Payload.Sheet)
+ sheetProjectID, sheetUID, err := common.GetProjectResourceIDSheetUID(revision.Payload.Sheet)
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheetUID from %q", revision.Payload.Sheet)
}
- sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID})
+ sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID, ProjectID: &sheetProjectID})
if err != nil {
return nil, errors.Wrapf(err, "failed to get sheet %q", revision.Payload.Sheet)
}
if sheet == nil {
- return nil, errors.Errorf("sheet %q not found", revision.Payload.Sheet)
+ return nil, errors.Errorf("sheet %d not found in project %s", sheetUID, sheetProjectID)
}
taskRunName, issueName := revision.Payload.TaskRun, ""
diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.go
index 4184794c3c..232dd85264 100644
--- a/backend/api/v1/rollout_service.go
+++ b/backend/api/v1/rollout_service.go
@@ -110,12 +110,10 @@ func (s *RolloutService) GetRollout(ctx context.Context, req *connect.Request[v1
if project == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %q not found", projectID))
}
- rollout, err := s.store.GetRollout(ctx, rolloutID)
+
+ rollout, err := s.getRolloutWithTasks(ctx, projectID, rolloutID)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get pipeline, error: %v", err))
- }
- if rollout == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout not found for id: %d", rolloutID))
+ return nil, err
}
rolloutV1, err := convertToRollout(ctx, s.store, project, rollout)
@@ -176,14 +174,13 @@ func (s *RolloutService) ListRollouts(ctx context.Context, req *connect.Request[
rollouts := []*v1pb.Rollout{}
for _, pipeline := range pipelines {
- rolloutMessage, err := s.store.GetRollout(ctx, pipeline.ID)
+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &pipeline.ID})
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
- }
- if rolloutMessage == nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout %d", pipeline.ID))
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks for pipeline %d, error: %v", pipeline.ID, err))
}
- rollout, err := convertToRollout(ctx, s.store, project, rolloutMessage)
+ rolloutMessage := *pipeline
+ rolloutMessage.Tasks = tasks
+ rollout, err := convertToRollout(ctx, s.store, project, &rolloutMessage)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert to rollout, error: %v", err))
}
@@ -236,12 +233,12 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Request
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
- plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &planID})
+ plan, err := s.store.GetPlan(ctx, &store.FindPlanMessage{UID: &planID, ProjectID: &projectID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get plan, error: %v", err))
}
if plan == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan not found for id: %d", planID))
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("plan %d not found in project %s", planID, projectID))
}
pipelineCreate, err := GetPipelineCreate(ctx, s.store, s.sheetManager, s.dbFactory, plan.Config.GetSpecs(), plan.Config.GetDeployment(), project)
@@ -267,9 +264,9 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Request
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to create pipeline, error: %v", err))
}
- rollout, err := s.store.GetRollout(ctx, pipelineUID)
+ rollout, err := s.getRolloutWithTasks(ctx, projectID, pipelineUID)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get pipeline, error: %v", err))
+ return nil, err
}
rolloutV1, err := convertToRollout(ctx, s.store, project, rollout)
@@ -301,6 +298,17 @@ func (s *RolloutService) ListTaskRuns(ctx context.Context, req *connect.Request[
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))
}
+ pipeline, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
+ }
+ if pipeline == nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
+ }
+
taskRuns, err := s.store.ListTaskRunsV2(ctx, &store.FindTaskRunMessage{
PipelineUID: &rolloutID,
Environment: maybeStageID,
@@ -322,14 +330,30 @@ func (s *RolloutService) ListTaskRuns(ctx context.Context, req *connect.Request[
// GetTaskRun gets a task run.
func (s *RolloutService) GetTaskRun(ctx context.Context, req *connect.Request[v1pb.GetTaskRunRequest]) (*connect.Response[v1pb.TaskRun], error) {
request := req.Msg
- _, _, _, _, taskRunUID, err := common.GetProjectIDRolloutIDStageIDTaskIDTaskRunID(request.Name)
+ projectID, rolloutID, _, _, taskRunUID, err := common.GetProjectIDRolloutIDStageIDTaskIDTaskRunID(request.Name)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
+
+ pipeline, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout, error: %v", err))
+ }
+ if pipeline == nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("pipeline %d not found in project %s", rolloutID, projectID))
+ }
+
taskRun, err := s.store.GetTaskRun(ctx, taskRunUID)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get task run, error: %v", err))
}
+ if taskRun == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("task run %d not found", taskRunUID))
+ }
+
taskRunV1, err := convertToTaskRun(ctx, s.store, s.stateCfg, taskRun)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert to task run, error: %v", err))
@@ -505,7 +529,10 @@ func (s *RolloutService) BatchRunTasks(ctx context.Context, req *connect.Request
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))
}
- rollout, err := s.store.GetPipelineV2ByID(ctx, rolloutID)
+ rollout, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find rollout, error: %v", err))
}
@@ -513,7 +540,10 @@ func (s *RolloutService) BatchRunTasks(ctx context.Context, req *connect.Request
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %v not found", rolloutID))
}
- issueN, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{PipelineID: &rolloutID})
+ issueN, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{
+ PipelineID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find issue, error: %v", err))
}
@@ -646,7 +676,10 @@ func (s *RolloutService) BatchSkipTasks(ctx context.Context, req *connect.Reques
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))
}
- rollout, err := s.store.GetPipelineV2ByID(ctx, rolloutID)
+ rollout, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find rollout, error: %v", err))
}
@@ -654,7 +687,10 @@ func (s *RolloutService) BatchSkipTasks(ctx context.Context, req *connect.Reques
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %v not found", rolloutID))
}
- issueN, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{PipelineID: &rolloutID})
+ issueN, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{
+ PipelineID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find issue, error: %v", err))
}
@@ -751,7 +787,10 @@ func (s *RolloutService) BatchCancelTaskRuns(ctx context.Context, req *connect.R
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("project %v not found", projectID))
}
- rollout, err := s.store.GetPipelineV2ByID(ctx, rolloutID)
+ rollout, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find rollout, error: %v", err))
}
@@ -759,7 +798,10 @@ func (s *RolloutService) BatchCancelTaskRuns(ctx context.Context, req *connect.R
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %v not found", rolloutID))
}
- issueN, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{PipelineID: &rolloutID})
+ issueN, err := s.store.GetIssueV2(ctx, &store.FindIssueMessage{
+ PipelineID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to find issue, error: %v", err))
}
@@ -1069,3 +1111,26 @@ func (s *RolloutService) canUserCancelEnvironmentTaskRun(ctx context.Context, us
func (s *RolloutService) canUserSkipEnvironmentTasks(ctx context.Context, user *store.UserMessage, project *store.ProjectMessage, issue *store.IssueMessage, environment string, creatorUID int) (bool, error) {
return s.canUserRunEnvironmentTasks(ctx, user, project, issue, environment, creatorUID)
}
+
+// getRolloutWithTasks retrieves a pipeline by ID with its tasks populated.
+func (s *RolloutService) getRolloutWithTasks(ctx context.Context, projectID string, rolloutID int) (*store.PipelineMessage, error) {
+ pipeline, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get pipeline, error: %v", err))
+ }
+ if pipeline == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))
+ }
+
+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &rolloutID})
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks, error: %v", err))
+ }
+
+ rollout := *pipeline
+ rollout.Tasks = tasks
+ return &rollout, nil
+}
diff --git a/backend/api/v1/rollout_service_task.go b/backend/api/v1/rollout_service_task.go
index 7b81b1af70..cd75e4638e 100644
--- a/backend/api/v1/rollout_service_task.go
+++ b/backend/api/v1/rollout_service_task.go
@@ -374,7 +374,7 @@ func getTaskCreatesFromChangeDatabaseConfigWithRelease(
}
// Fetch the release
- release, err := s.GetRelease(ctx, releaseUID)
+ release, err := s.GetReleaseByUID(ctx, releaseUID)
if err != nil {
return nil, errors.Wrapf(err, "failed to get release %d", releaseUID)
}
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.go
index f2fb14ba1f..dac2d45fe4 100644
--- a/backend/api/v1/sql_service.go
+++ b/backend/api/v1/sql_service.go
@@ -781,29 +781,34 @@ func (s *SQLService) Export(ctx context.Context, req *connect.Request[v1pb.Expor
func (s *SQLService) doExportFromIssue(ctx context.Context, requestName string) (*v1pb.ExportResponse, error) {
// Try to parse as rollout name first (more specific), then fallback to stage name
var rolloutID int
+ var projectID string
var err error
- _, rolloutID, err = common.GetProjectIDRolloutID(requestName)
+ projectID, rolloutID, err = common.GetProjectIDRolloutID(requestName)
if err != nil {
// If rollout parsing fails, try parsing as stage name
- _, rolloutID, _, err = common.GetProjectIDRolloutIDMaybeStageID(requestName)
+ projectID, rolloutID, _, err = common.GetProjectIDRolloutIDMaybeStageID(requestName)
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to parse request name as rollout or stage: %v", err))
}
}
- rollout, err := s.store.GetRollout(ctx, rolloutID)
+
+ pipeline, err := s.store.GetPipelineV2(ctx, &store.PipelineFind{
+ ID: &rolloutID,
+ ProjectID: &projectID,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get rollout: %v", err))
}
- if rollout == nil {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found", rolloutID))
+ if pipeline == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("rollout %d not found in project %s", rolloutID, projectID))
}
- tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &rollout.ID})
+ tasks, err := s.store.ListTasks(ctx, &store.TaskFind{PipelineID: &pipeline.ID})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get tasks: %v", err))
}
if len(tasks) == 0 {
- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("rollout %d has no task", rollout.ID))
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("rollout %d has no task", pipeline.ID))
}
pendingEncrypts := []*encryptContent{}
diff --git a/backend/store/pipeline.go b/backend/store/pipeline.go
index a86b9810b1..228e9e3dba 100644
--- a/backend/store/pipeline.go
+++ b/backend/store/pipeline.go
@@ -202,12 +202,14 @@ func (*Store) createPipeline(ctx context.Context, txn *sql.Tx, create *PipelineM
return pipeline, nil
}
-// GetPipelineV2ByID gets the pipeline by ID.
-func (s *Store) GetPipelineV2ByID(ctx context.Context, id int) (*PipelineMessage, error) {
- if v, ok := s.pipelineCache.Get(id); ok && s.enableCache {
- return v, nil
+// GetPipelineV2 gets the pipeline.
+func (s *Store) GetPipelineV2(ctx context.Context, find *PipelineFind) (*PipelineMessage, error) {
+ if find.ID != nil {
+ if v, ok := s.pipelineCache.Get(*find.ID); ok && s.enableCache {
+ return v, nil
+ }
}
- pipelines, err := s.ListPipelineV2(ctx, &PipelineFind{ID: &id})
+ pipelines, err := s.ListPipelineV2(ctx, find)
if err != nil {
return nil, err
}
@@ -221,6 +223,11 @@ func (s *Store) GetPipelineV2ByID(ctx context.Context, id int) (*PipelineMessage
return pipeline, nil
}
+// GetPipelineV2ByID gets the pipeline by ID.
+func (s *Store) GetPipelineV2ByID(ctx context.Context, id int) (*PipelineMessage, error) {
+ return s.GetPipelineV2(ctx, &PipelineFind{ID: &id})
+}
+
// ListPipelineV2 lists pipelines.
func (s *Store) ListPipelineV2(ctx context.Context, find *PipelineFind) ([]*PipelineMessage, error) {
q := qb.Q().Space(`
diff --git a/backend/store/release.go b/backend/store/release.go
index ee3c3fb63e..6ee36d5c87 100644
--- a/backend/store/release.go
+++ b/backend/store/release.go
@@ -89,8 +89,8 @@ func (s *Store) CreateRelease(ctx context.Context, release *ReleaseMessage, crea
return release, nil
}
-func (s *Store) GetRelease(ctx context.Context, uid int64) (*ReleaseMessage, error) {
- releases, err := s.ListReleases(ctx, &FindReleaseMessage{UID: &uid, ShowDeleted: true})
+func (s *Store) GetReleaseV2(ctx context.Context, find *FindReleaseMessage) (*ReleaseMessage, error) {
+ releases, err := s.ListReleases(ctx, find)
if err != nil {
return nil, errors.Wrapf(err, "failed to list releases")
}
@@ -98,11 +98,15 @@ func (s *Store) GetRelease(ctx context.Context, uid int64) (*ReleaseMessage, err
return nil, nil
}
if len(releases) > 1 {
- return nil, errors.Errorf("found %d releases with uid=%v, expect 1", len(releases), uid)
+ return nil, errors.Errorf("found %d releases, expect 1", len(releases))
}
return releases[0], nil
}
+func (s *Store) GetReleaseByUID(ctx context.Context, uid int64) (*ReleaseMessage, error) {
+ return s.GetReleaseV2(ctx, &FindReleaseMessage{UID: &uid, ShowDeleted: true})
+}
+
func (s *Store) ListReleases(ctx context.Context, find *FindReleaseMessage) ([]*ReleaseMessage, error) {
q := qb.Q().Space(`
SELECT
@@ -228,5 +232,5 @@ func (s *Store) UpdateRelease(ctx context.Context, update *UpdateReleaseMessage)
return nil, errors.Wrapf(err, "failed to commit tx")
}
- return s.GetRelease(ctx, update.UID)
+ return s.GetReleaseByUID(ctx, update.UID)
}
diff --git a/backend/store/rollout.go b/backend/store/rollout.go
deleted file mode 100644
index 6018002d27..0000000000
--- a/backend/store/rollout.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package store
-
-import (
- "context"
-
- "github.com/pkg/errors"
-)
-
-// GetRollout gets the rollout by rollout ID.
-func (s *Store) GetRollout(ctx context.Context, rolloutID int) (*PipelineMessage, error) {
- tasks, err := s.ListTasks(ctx, &TaskFind{PipelineID: &rolloutID})
- if err != nil {
- return nil, errors.Wrapf(err, "failed to find tasks for pipeline %d", rolloutID)
- }
- pipeline, err := s.GetPipelineV2ByID(ctx, rolloutID)
- if err != nil {
- return nil, errors.Wrapf(err, "failed to get pipeline")
- }
- if pipeline == nil {
- return nil, nil
- }
- rollout := *pipeline
- rollout.Tasks = tasks
-
- return &rollout, nil
-}