Skip to content

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

refactor: inline getDatabaseMessage at all call sites (#18560)

Danny Xu850fd4ebd269
diff --git a/backend/api/v1/acl.go b/backend/api/v1/acl.go
index 857b4cd17a..9e2dda625e 100644
--- a/backend/api/v1/acl.go
+++ b/backend/api/v1/acl.go
@@ -246,9 +246,19 @@ func populateRawResources(ctx context.Context, stores *store.Store, authContext
case strings.HasPrefix(resource.Name, "instances/") && strings.Contains(resource.Name, "/databases/") && !strings.HasPrefix(resource.Name, "instances/-/databases/"):
match := databaseRegex.FindString(resource.Name)
if match != "" {
- database, err := getDatabaseMessage(ctx, stores, match)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(match)
if err != nil {
- return errors.Wrapf(err, "failed to get database %q", match)
+ return errors.Wrapf(err, "failed to parse %q", match)
+ }
+ database, err := stores.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return errors.Wrapf(err, "failed to get database")
+ }
+ if database == nil {
+ return errors.Errorf("database %q not found", match)
}
resource.ProjectID = database.ProjectID
}
diff --git a/backend/api/v1/common.go b/backend/api/v1/common.go
index 2fb99298f3..12062e31cb 100644
--- a/backend/api/v1/common.go
+++ b/backend/api/v1/common.go
@@ -444,37 +444,6 @@ func convertToExportFormat(format v1pb.ExportFormat) storepb.ExportFormat {
return storepb.ExportFormat_FORMAT_UNSPECIFIED
}
-// getDatabaseMessage retrieves a database by parsing the database resource name.
-// This is a common utility function to avoid code duplication across services.
-func getDatabaseMessage(ctx context.Context, s *store.Store, databaseResourceName string) (*store.DatabaseMessage, error) {
- instanceID, databaseName, err := common.GetInstanceDatabaseID(databaseResourceName)
- if err != nil {
- return nil, errors.Wrapf(err, "failed to parse %q", databaseResourceName)
- }
-
- instance, err := s.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &instanceID})
- if err != nil {
- return nil, errors.Wrapf(err, "failed to get instance %s", instanceID)
- }
- if instance == nil {
- return nil, errors.Errorf("instance not found")
- }
-
- find := &store.FindDatabaseMessage{
- InstanceID: &instanceID,
- DatabaseName: &databaseName,
- ShowDeleted: true,
- }
- database, err := s.GetDatabase(ctx, find)
- if err != nil {
- return nil, errors.Wrapf(err, "failed to get database")
- }
- if database == nil {
- return nil, errors.Errorf("database %q not found", databaseResourceName)
- }
- return database, nil
-}
-
func GetUserFromContext(ctx context.Context) (*store.UserMessage, bool) {
user, ok := ctx.Value(common.UserContextKey).(*store.UserMessage)
return user, ok
diff --git a/backend/api/v1/database_catalog_service.go b/backend/api/v1/database_catalog_service.go
index 08d500b646..c40b1105f7 100644
--- a/backend/api/v1/database_catalog_service.go
+++ b/backend/api/v1/database_catalog_service.go
@@ -37,9 +37,19 @@ func (s *DatabaseCatalogService) GetDatabaseCatalog(ctx context.Context, req *co
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
- database, err := getDatabaseMessage(ctx, s.store, databaseResourceName)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(databaseResourceName)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, err)
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", databaseResourceName))
+ }
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if database == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", databaseResourceName))
}
dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
@@ -64,9 +74,19 @@ func (s *DatabaseCatalogService) UpdateDatabaseCatalog(ctx context.Context, req
return nil, connect.NewError(connect.CodeInvalidArgument, err)
}
- database, err := getDatabaseMessage(ctx, s.store, databaseResourceName)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(databaseResourceName)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, err)
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", databaseResourceName))
+ }
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if database == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", databaseResourceName))
}
dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
diff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.go
index fb20962487..81de6a9278 100644
--- a/backend/api/v1/database_service.go
+++ b/backend/api/v1/database_service.go
@@ -50,12 +50,19 @@ func NewDatabaseService(store *store.Store, schemaSyncer *schemasync.Syncer, lic
// GetDatabase gets a database.
func (s *DatabaseService) GetDatabase(ctx context.Context, req *connect.Request[v1pb.GetDatabaseRequest]) (*connect.Response[v1pb.Database], error) {
- databaseMessage, err := getDatabaseMessage(ctx, s.store, req.Msg.Name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(req.Msg.Name)
if err != nil {
- return nil, err
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", req.Msg.Name))
}
- if databaseMessage.Deleted {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q was deleted", req.Msg.Name))
+ databaseMessage, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if databaseMessage == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", req.Msg.Name))
}
database, err := s.convertToDatabase(ctx, databaseMessage)
if err != nil {
@@ -83,11 +90,19 @@ func (s *DatabaseService) BatchGetDatabases(ctx context.Context, req *connect.Re
databases := make([]*v1pb.Database, 0, len(req.Msg.Names))
for _, name := range req.Msg.Names {
- databaseMessage, err := getDatabaseMessage(ctx, s.store, name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(name)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", name))
+ }
+ find := &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ }
+ databaseMessage, err := s.store.GetDatabase(ctx, find)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get database %q with error: %v", name, err.Error()))
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
}
- if databaseMessage.Deleted {
+ if databaseMessage == nil {
// Ignore deleted database.
continue
}
@@ -259,16 +274,19 @@ func (s *DatabaseService) UpdateDatabase(ctx context.Context, req *connect.Reque
}
// Use the helper function to get the database
- databaseMessage, err := getDatabaseMessage(ctx, s.store, req.Msg.Database.Name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(req.Msg.Database.Name)
if err != nil {
- // Check if it's a not found error and allow_missing is true
- if strings.Contains(err.Error(), "not found") && req.Msg.AllowMissing {
- // Database creation is not supported through UpdateDatabase API.
- // Databases must be created through the plan and rollout system.
- return nil, connect.NewError(connect.CodeUnimplemented, errors.Errorf("database creation is not supported through UpdateDatabase, use plan and rollout instead"))
- }
- // For other errors or when allow_missing is false, return the error
- return nil, connect.NewError(connect.CodeInvalidArgument, err)
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", req.Msg.Database.Name))
+ }
+ databaseMessage, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if databaseMessage == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", req.Msg.Database.Name))
}
if databaseMessage.Deleted {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q was deleted", req.Msg.Database.Name))
@@ -370,9 +388,19 @@ func (s *DatabaseService) UpdateDatabase(ctx context.Context, req *connect.Reque
// SyncDatabase syncs the schema of a database.
func (s *DatabaseService) SyncDatabase(ctx context.Context, req *connect.Request[v1pb.SyncDatabaseRequest]) (*connect.Response[v1pb.SyncDatabaseResponse], error) {
- databaseMessage, err := getDatabaseMessage(ctx, s.store, req.Msg.Name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(req.Msg.Name)
if err != nil {
- return nil, err
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", req.Msg.Name))
+ }
+ databaseMessage, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if databaseMessage == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", req.Msg.Name))
}
if databaseMessage.Deleted {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q was deleted", req.Msg.Name))
@@ -386,11 +414,18 @@ func (s *DatabaseService) SyncDatabase(ctx context.Context, req *connect.Request
// BatchSyncDatabases sync multiply database asynchronously.
func (s *DatabaseService) BatchSyncDatabases(ctx context.Context, req *connect.Request[v1pb.BatchSyncDatabasesRequest]) (*connect.Response[v1pb.BatchSyncDatabasesResponse], error) {
for _, name := range req.Msg.Names {
- databaseMessage, err := getDatabaseMessage(ctx, s.store, name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(name)
if err != nil {
- return nil, err
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", name))
+ }
+ databaseMessage, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
}
- if databaseMessage.Deleted {
+ if databaseMessage == nil {
continue
}
s.schemaSyncer.SyncDatabaseAsync(databaseMessage)
@@ -498,12 +533,19 @@ func (s *DatabaseService) GetDatabaseMetadata(ctx context.Context, req *connect.
if err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))
}
- database, err := getDatabaseMessage(ctx, s.store, name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(name)
if err != nil {
- return nil, err
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", name))
}
- if database.Deleted {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q was deleted", name))
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if database == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", name))
}
dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
@@ -949,9 +991,19 @@ type metadataFilter struct {
}
func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Request[v1pb.GetSchemaStringRequest]) (*connect.Response[v1pb.GetSchemaStringResponse], error) {
- database, err := getDatabaseMessage(ctx, s.store, req.Msg.Name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(req.Msg.Name)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("%v", err.Error()))
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", req.Msg.Name))
+ }
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database %q", req.Msg.Name))
+ }
+ if database == nil {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", req.Msg.Name))
}
instance, err := s.store.GetInstance(ctx, &store.FindInstanceMessage{ResourceID: &database.InstanceID})
@@ -963,8 +1015,8 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
- InstanceID: database.InstanceID,
- DatabaseName: database.DatabaseName,
+ InstanceID: instanceID,
+ DatabaseName: databaseName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("Failed to get database schema: %v", err))
diff --git a/backend/api/v1/database_service_changelog.go b/backend/api/v1/database_service_changelog.go
index a52383b714..4140776352 100644
--- a/backend/api/v1/database_service_changelog.go
+++ b/backend/api/v1/database_service_changelog.go
@@ -15,11 +15,18 @@ import (
)
func (s *DatabaseService) ListChangelogs(ctx context.Context, req *connect.Request[v1pb.ListChangelogsRequest]) (*connect.Response[v1pb.ListChangelogsResponse], error) {
- database, err := getDatabaseMessage(ctx, s.store, req.Msg.Parent)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(req.Msg.Parent)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, err)
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", req.Msg.Parent))
+ }
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
}
- if database == nil || database.Deleted {
+ if database == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", req.Msg.Parent))
}
diff --git a/backend/api/v1/issue_service.go b/backend/api/v1/issue_service.go
index 13784ea319..06ac4dbd6b 100644
--- a/backend/api/v1/issue_service.go
+++ b/backend/api/v1/issue_service.go
@@ -124,15 +124,16 @@ func (s *IssueService) getIssueFind(
}
issueFind.InstanceResourceID = &instanceResourceID
case "database":
- database, err := getDatabaseMessage(ctx, s.store, value.(string))
- if err != nil {
- return "", connect.NewError(connect.CodeInternal, errors.Errorf("%v", err.Error()))
+ databaseResourceName, ok := value.(string)
+ if !ok {
+ return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("failed to parse database value %v to string", value))
}
- if database == nil || database.Deleted {
- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf(`database "%q" not found`, value))
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(databaseResourceName)
+ if err != nil {
+ return "", connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to parse %q", databaseResourceName))
}
- issueFind.InstanceID = &database.InstanceID
- issueFind.DatabaseName = &database.DatabaseName
+ issueFind.InstanceID = &instanceID
+ issueFind.DatabaseName = &databaseName
case "environment":
environment, ok := value.(string)
if !ok {
diff --git a/backend/api/v1/plan_service_plan_check.go b/backend/api/v1/plan_service_plan_check.go
index c737a69e9b..c354009796 100644
--- a/backend/api/v1/plan_service_plan_check.go
+++ b/backend/api/v1/plan_service_plan_check.go
@@ -121,9 +121,19 @@ func getPlanCheckRunsFromChangeDatabaseConfigDatabaseGroupTarget(ctx context.Con
var planCheckRuns []*store.PlanCheckRunMessage
for _, matchedDatabase := range databaseGroup.MatchedDatabases {
for _, sheetSha256 := range sheetSha256s {
- database, err := getDatabaseMessage(ctx, s, matchedDatabase.Name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(matchedDatabase.Name)
if err != nil {
- return nil, err
+ return nil, errors.Wrapf(err, "failed to parse %q", matchedDatabase.Name)
+ }
+ database, err := s.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get database")
+ }
+ if database == nil {
+ return nil, errors.Errorf("database %q not found", matchedDatabase.Name)
}
runs, err := getPlanCheckRunsFromChangeDatabaseConfigForDatabase(ctx, s, plan, config, sheetSha256, database)
if err != nil {
@@ -144,12 +154,19 @@ func getPlanCheckRunsFromChangeDatabaseConfigDatabaseTarget(ctx context.Context,
var checks []*store.PlanCheckRunMessage
for _, target := range config.Targets {
- database, err := getDatabaseMessage(ctx, s, target)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(target)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to parse %q", target)
+ }
+ database, err := s.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
if err != nil {
- return nil, err
+ return nil, errors.Wrapf(err, "failed to get database")
}
- if database.Deleted {
- return nil, errors.Errorf("database %q was deleted", target)
+ if database == nil {
+ return nil, errors.Errorf("database %q not found", target)
}
for _, sheetSha256 := range sheetSha256s {
v, err := getPlanCheckRunsFromChangeDatabaseConfigForDatabase(ctx, s, plan, config, sheetSha256, database)
diff --git a/backend/api/v1/release_service_check.go b/backend/api/v1/release_service_check.go
index 4359b8cc62..4bd36aeec5 100644
--- a/backend/api/v1/release_service_check.go
+++ b/backend/api/v1/release_service_check.go
@@ -51,12 +51,15 @@ func (s *ReleaseService) CheckRelease(ctx context.Context, req *connect.Request[
var targetDatabases []*store.DatabaseMessage
for _, target := range request.Targets {
// Handle database target.
- if _, _, err := common.GetInstanceDatabaseID(target); err == nil {
- database, err := getDatabaseMessage(ctx, s.store, target)
+ if instanceID, databaseName, err := common.GetInstanceDatabaseID(target); err == nil {
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to found database %v", target))
}
- if database == nil || database.Deleted {
+ if database == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %v not found", target))
}
targetDatabases = append(targetDatabases, database)
diff --git a/backend/api/v1/revision_service.go b/backend/api/v1/revision_service.go
index 4d0c910cf0..99b0675921 100644
--- a/backend/api/v1/revision_service.go
+++ b/backend/api/v1/revision_service.go
@@ -37,11 +37,18 @@ func (s *RevisionService) ListRevisions(
req *connect.Request[v1pb.ListRevisionsRequest],
) (*connect.Response[v1pb.ListRevisionsResponse], error) {
request := req.Msg
- database, err := getDatabaseMessage(ctx, s.store, request.Parent)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(request.Parent)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to found database %v", request.Parent))
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", request.Parent))
}
- if database == nil || database.Deleted {
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if database == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %v not found", request.Parent))
}
@@ -113,11 +120,18 @@ func (s *RevisionService) BatchCreateRevisions(
req *connect.Request[v1pb.BatchCreateRevisionsRequest],
) (*connect.Response[v1pb.BatchCreateRevisionsResponse], error) {
request := req.Msg
- database, err := getDatabaseMessage(ctx, s.store, request.Parent)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(request.Parent)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to found database %v", request.Parent))
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", request.Parent))
}
- if database == nil || database.Deleted {
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if database == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %v not found", request.Parent))
}
diff --git a/backend/api/v1/rollout_service_task.go b/backend/api/v1/rollout_service_task.go
index e82e4481e0..7be1642985 100644
--- a/backend/api/v1/rollout_service_task.go
+++ b/backend/api/v1/rollout_service_task.go
@@ -213,21 +213,35 @@ func getDatabaseMessagesByTargets(ctx context.Context, s *store.Store, targets [
return nil, errors.Wrapf(err, "failed to get database group %q", target)
}
for _, matched := range databaseGroup.MatchedDatabases {
- database, err := getDatabaseMessage(ctx, s, matched.Name)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(matched.Name)
if err != nil {
- return nil, err
+ return nil, errors.Wrapf(err, "failed to parse %q", matched.Name)
}
- if database == nil || database.Deleted {
- return nil, errors.Errorf("database %q not found", target)
+ database, err := s.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get database")
+ }
+ if database == nil {
+ return nil, errors.Errorf("database %q not found", matched.Name)
}
databases = append(databases, database)
}
} else if _, _, err := common.GetInstanceDatabaseID(target); err == nil {
- database, err := getDatabaseMessage(ctx, s, target)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(target)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to parse %q", target)
+ }
+ database, err := s.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
if err != nil {
- return nil, err
+ return nil, errors.Wrapf(err, "failed to get database")
}
- if database == nil || database.Deleted {
+ if database == nil {
return nil, errors.Errorf("database %q not found", target)
}
databases = append(databases, database)
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.go
index 5e3a8d1837..e48b47089d 100644
--- a/backend/api/v1/sql_service.go
+++ b/backend/api/v1/sql_service.go
@@ -1594,9 +1594,19 @@ func (s *SQLService) prepareRelatedMessage(ctx context.Context, requestName stri
return nil, nil, nil, connect.NewError(connect.CodeInternal, errors.New(err.Error()))
}
- database, err := getDatabaseMessage(ctx, s.store, requestName)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(requestName)
if err != nil {
- return nil, nil, nil, connect.NewError(connect.CodeInternal, errors.New(err.Error()))
+ return nil, nil, nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to parse %q", requestName))
+ }
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, nil, nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
+ }
+ if database == nil {
+ return nil, nil, nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", requestName))
}
instance, err := s.store.GetInstance(ctx, &store.FindInstanceMessage{
diff --git a/backend/api/v1/worksheet_service.go b/backend/api/v1/worksheet_service.go
index feceebf52f..3857b162b9 100644
--- a/backend/api/v1/worksheet_service.go
+++ b/backend/api/v1/worksheet_service.go
@@ -67,17 +67,24 @@ func (s *WorksheetService) CreateWorksheet(
var database *store.DatabaseMessage
if request.Worksheet.Database != "" {
- db, err := getDatabaseMessage(ctx, s.store, request.Worksheet.Database)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(request.Worksheet.Database)
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, err)
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", request.Worksheet.Database))
}
- // Verify the database belongs to the specified project
- if db.ProjectID != projectResourceID {
- return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found in project %q", request.Worksheet.Database, projectResourceID))
+ db, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
}
if db == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", request.Worksheet.Database))
}
+ // Verify the database belongs to the specified project
+ if db.ProjectID != projectResourceID {
+ return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found in project %q", request.Worksheet.Database, projectResourceID))
+ }
database = db
}
storeWorksheetCreate, err := convertToStoreWorksheetMessage(project, database, user.Email, request.Worksheet)
@@ -255,11 +262,18 @@ func (s *WorksheetService) UpdateWorksheet(
worksheetPatch.Visibility = &stringVisibility
case "database":
if request.Worksheet.Database != "" {
- database, err := getDatabaseMessage(ctx, s.store, request.Worksheet.Database)
+ instanceID, databaseName, err := common.GetInstanceDatabaseID(request.Worksheet.Database)
+ if err != nil {
+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrapf(err, "failed to parse %q", request.Worksheet.Database))
+ }
+ database, err := s.store.GetDatabase(ctx, &store.FindDatabaseMessage{
+ InstanceID: &instanceID,
+ DatabaseName: &databaseName,
+ })
if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to found database %v", request.Worksheet.Database))
+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database"))
}
- if database == nil || database.Deleted {
+ if database == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %v not found", request.Worksheet.Database))
}
worksheetPatch.InstanceID, worksheetPatch.DatabaseName = &database.InstanceID, &database.DatabaseName
diff --git a/backend/tests/action_test.go b/backend/tests/action_test.go
index 69ec4f3c10..17b7078a65 100644
--- a/backend/tests/action_test.go
+++ b/backend/tests/action_test.go
@@ -1849,7 +1849,7 @@ func TestActionErrorScenarios(t *testing.T) {
)
a.Error(err, "Command should fail with non-existent database")
- a.Contains(result.Stderr, "failed to found database", "Expected not found error in stderr")
+ a.Contains(result.Stderr, "database instances/fake/databases/nonexistent not found", "Expected not found error in stderr")
})
t.Run("EmptyFilePattern", func(t *testing.T) {